Wire OTel LoggerProvider into logfire-node + expose forceFlush/shutdown

`withOnlineEvaluation` emits `gen_ai.evaluation.result` log records via
the OTel api-logs API, but logfire-node never configured a LoggerProvider
or OTLP logs exporter — records fell through to the OTel SDK's default
`localhost:4318/v1/logs`, which on most setups silently dropped them. Add
a BatchLogRecordProcessor pointing at `${baseUrl}/v1/logs` (alongside the
existing trace + metric exporters) by passing it to NodeSDK's
`logRecordProcessors`. Verified end-to-end against the local platform:
log records now POST to `localhost:3000/v1/logs` and the Live Evaluations
UI lights up with target/eval rows.

Also expose `logfire.forceFlush()` and `logfire.shutdown()` from
logfire-node, mirroring Python's `logfire.force_flush()`. The previous
`beforeExit` cleanup was racy for short-lived scripts that top-level-await
once and exit before the OTel batch processor's 5-second scheduledDelay
fires. Demos now call these explicitly so spans land deterministically.

Drop `dotenv/config` from the demo scripts: env-loaded config can silently
override the local-dev defaults (caught when `LOGFIRE_BASE_URL` in a stray
.env pointed at port 8000 instead of 3000). Demos now use their hard-coded
local-platform defaults; users wanting to point elsewhere can set env vars
explicitly via shell.

Author: dmontagu

examples/node/demo_evals.ts

@@ -19,7 +19,6 @@
  * to inspect the resulting experiment.
  */
 
-import 'dotenv/config'
 import { resolve } from 'node:path'
 
 import * as logfire from '@pydantic/logfire-node'
@@ -143,5 +142,8 @@ async function evaluateDataset(): Promise<void> {
 }
 
 await evaluateDataset()
-// Force-flush the OTel SDK so the experiment lands before the process exits.
-await new Promise((resolve) => setTimeout(resolve, 1500))
+// Force-flush pending spans so we don't race the OTel batch processor's
+// 5-second scheduled-delay against process exit. Mirrors the Python demo's
+// `logfire.force_flush()` at the end of the script.
+await logfire.forceFlush()
+await logfire.shutdown()

examples/node/demo_online_evals.ts

@@ -14,7 +14,6 @@
  * `math_agent` — http://localhost:3000/e2e-test/test-e2e-project/evals/live
  */
 
-import 'dotenv/config'
 import * as logfire from '@pydantic/logfire-node'
 import {
   Evaluator,
@@ -132,6 +131,6 @@ await runTarget('math_agent', MATH_CASES)
 
 console.log('\nFlushing pending evaluations…')
 await waitForEvaluations({ timeoutMs: 10_000 })
-// Give the OTel batch processor a moment to ship the events.
-await new Promise((r) => setTimeout(r, 1500))
+await logfire.forceFlush()
+await logfire.shutdown()
 console.log('Done. Open the Live Evaluations UI to confirm events landed for both targets.')

packages/logfire-node/package.json

@@ -68,27 +68,33 @@
   },
   "devDependencies": {
     "@opentelemetry/api": "catalog:",
+    "@opentelemetry/api-logs": "catalog:",
     "@opentelemetry/auto-instrumentations-node": "catalog:",
     "@opentelemetry/context-async-hooks": "catalog:",
     "@opentelemetry/core": "catalog:",
+    "@opentelemetry/exporter-logs-otlp-proto": "catalog:",
     "@opentelemetry/exporter-metrics-otlp-proto": "catalog:",
     "@opentelemetry/exporter-trace-otlp-proto": "catalog:",
     "@opentelemetry/instrumentation": "catalog:",
     "@opentelemetry/resources": "catalog:",
+    "@opentelemetry/sdk-logs": "catalog:",
     "@opentelemetry/sdk-metrics": "catalog:",
     "@opentelemetry/sdk-node": "catalog:",
     "@opentelemetry/sdk-trace-base": "catalog:",
     "@opentelemetry/semantic-conventions": "catalog:"
   },
   "peerDependencies": {
     "@opentelemetry/api": "catalog:",
+    "@opentelemetry/api-logs": "catalog:",
     "@opentelemetry/auto-instrumentations-node": "catalog:",
     "@opentelemetry/context-async-hooks": "catalog:",
     "@opentelemetry/core": "catalog:",
+    "@opentelemetry/exporter-logs-otlp-proto": "catalog:",
     "@opentelemetry/exporter-metrics-otlp-proto": "catalog:",
     "@opentelemetry/exporter-trace-otlp-proto": "catalog:",
     "@opentelemetry/instrumentation": "catalog:",
     "@opentelemetry/resources": "catalog:",
+    "@opentelemetry/sdk-logs": "catalog:",
     "@opentelemetry/sdk-metrics": "catalog:",
     "@opentelemetry/sdk-node": "catalog:",
     "@opentelemetry/sdk-trace-base": "catalog:",

packages/logfire-node/src/index.ts

@@ -24,8 +24,10 @@ import {
 
 // Import all exports to construct default export
 import * as logfireConfigExports from './logfireConfig'
+import { forceFlush, shutdown } from './sdk'
 
 export * from './logfireConfig'
+export { forceFlush, shutdown } from './sdk'
 export { DiagLogLevel } from '@opentelemetry/api'
 export * from 'logfire'
 
@@ -37,6 +39,7 @@ export default {
   DiagLogLevel,
   error,
   fatal,
+  forceFlush,
   info,
   // Re-export all from logfire
   Level,
@@ -49,6 +52,7 @@ export default {
   resolveBaseUrl,
   resolveSendToLogfire,
   serializeAttributes,
+  shutdown,
   span,
   startSpan,
   trace,

packages/logfire-node/src/logfireConfig.ts

@@ -129,6 +129,7 @@ export interface LogfireConfigOptions {
 const DEFAULT_OTEL_SCOPE = 'logfire'
 const TRACE_ENDPOINT_PATH = 'v1/traces'
 const METRIC_ENDPOINT_PATH = 'v1/metrics'
+const LOGS_ENDPOINT_PATH = 'v1/logs'
 const DEFAULT_AUTO_INSTRUMENTATION_CONFIG: InstrumentationConfigMap = {
   // https://opentelemetry.io/docs/languages/js/libraries/#registration
   // This particular instrumentation creates a lot of noise on startup
@@ -148,6 +149,7 @@ export interface LogfireConfig {
   distributedTracing: boolean
   idGenerator: IdGenerator
   instrumentations: Instrumentation[]
+  logsExporterUrl: string
   metricExporterUrl: string
   metrics: false | MetricsOptions | undefined
   nodeAutoInstrumentations: InstrumentationConfigMap
@@ -171,6 +173,7 @@ const DEFAULT_LOGFIRE_CONFIG: LogfireConfig = {
   distributedTracing: true,
   idGenerator: new logfireApi.ULIDGenerator(),
   instrumentations: [],
+  logsExporterUrl: '',
   metricExporterUrl: '',
   metrics: undefined,
   nodeAutoInstrumentations: DEFAULT_AUTO_INSTRUMENTATION_CONFIG,
@@ -212,6 +215,7 @@ export function configure(config: LogfireConfigOptions = {}) {
     distributedTracing: resolveDistributedTracing(cnf.distributedTracing),
     idGenerator: cnf.advanced?.idGenerator ?? new logfireApi.ULIDGenerator(),
     instrumentations: cnf.instrumentations ?? [],
+    logsExporterUrl: `${baseUrl}/${LOGS_ENDPOINT_PATH}`,
     metricExporterUrl: `${baseUrl}/${METRIC_ENDPOINT_PATH}`,
     metrics: cnf.metrics,
     nodeAutoInstrumentations: cnf.nodeAutoInstrumentations ?? DEFAULT_AUTO_INSTRUMENTATION_CONFIG,

packages/logfire-node/src/logsExporter.ts

@@ -0,0 +1,23 @@
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-proto'
+import { BatchLogRecordProcessor, LogRecordProcessor } from '@opentelemetry/sdk-logs'
+
+import { logfireConfig } from './logfireConfig'
+
+/**
+ * Returns a `BatchLogRecordProcessor` wired to the Logfire OTLP /v1/logs endpoint.
+ * Used by `withOnlineEvaluation` to ship `gen_ai.evaluation.result` log events.
+ *
+ * Returns null when sendToLogfire is disabled — the OTel API logs methods will
+ * become no-ops.
+ */
+export function logfireLogRecordProcessor(): LogRecordProcessor | null {
+  if (!logfireConfig.sendToLogfire || !logfireConfig.token) {
+    return null
+  }
+  return new BatchLogRecordProcessor(
+    new OTLPLogExporter({
+      headers: logfireConfig.authorizationHeaders,
+      url: logfireConfig.logsExporterUrl,
+    })
+  )
+}

packages/logfire-node/src/sdk.ts

@@ -23,10 +23,37 @@ import { reportError, TailSamplingProcessor, ULIDGenerator } from 'logfire'
 import { getEvalsSpanProcessor } from 'logfire/evals'
 
 import { logfireConfig } from './logfireConfig'
+import { logfireLogRecordProcessor } from './logsExporter'
 import { periodicMetricReader } from './metricExporter'
 import { logfireSpanProcessor } from './traceExporter'
 import { removeEmptyKeys } from './utils'
 
+let activeSdk: NodeSDK | undefined
+let activeProcessor: import('@opentelemetry/sdk-trace-base').SpanProcessor | undefined
+
+/**
+ * Force-flush all pending spans to the configured exporter. Mirrors Python's
+ * `logfire.force_flush()`. Call this before process exit when the default
+ * `beforeExit` cleanup might not have time to finish (e.g. short scripts that
+ * top-level-await once and exit).
+ */
+export async function forceFlush(): Promise<void> {
+  if (activeProcessor) {
+    await activeProcessor.forceFlush()
+  }
+}
+
+/**
+ * Shut down the OTel SDK, flushing pending spans and metrics. Idempotent —
+ * subsequent calls are no-ops. Mirrors Python's `logfire.shutdown()`.
+ */
+export async function shutdown(): Promise<void> {
+  if (activeSdk) {
+    await activeSdk.shutdown()
+    activeSdk = undefined
+  }
+}
+
 const LOGFIRE_ATTRIBUTES_NAMESPACE = 'logfire'
 const RESOURCE_ATTRIBUTES_CODE_ROOT_PATH = `${LOGFIRE_ATTRIBUTES_NAMESPACE}.code.root_path`
 
@@ -60,16 +87,20 @@ export function start() {
   if (logfireConfig.sampling?.tail) {
     processor = new TailSamplingProcessor(processor, logfireConfig.sampling.tail)
   }
+  activeProcessor = processor
 
   const headRate = logfireConfig.sampling?.head
   const sampler =
     headRate !== undefined && headRate < 1.0 ? new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(headRate) }) : undefined
 
+  const logProcessor = logfireLogRecordProcessor()
+
   const sdk = new NodeSDK({
     autoDetectResources: false,
     contextManager,
     idGenerator: new ULIDGenerator(),
     instrumentations: [getNodeAutoInstrumentations(logfireConfig.nodeAutoInstrumentations), ...logfireConfig.instrumentations],
+    ...(logProcessor ? { logRecordProcessors: [logProcessor] } : {}),
     metricReader: logfireConfig.metrics === false ? undefined : periodicMetricReader(),
     resource,
     ...(sampler ? { sampler } : {}),
@@ -82,6 +113,7 @@ export function start() {
     metrics.setGlobalMeterProvider(meterProvider)
   }
 
+  activeSdk = sdk
   sdk.start()
   diag.info('logfire: starting')