Import otel Cloudflare Workers package (#154)

Author: petyosi

.changeset/brave-cloudflare-workers.md

@@ -0,0 +1,8 @@
+---
+"@pydantic/logfire-cf-workers": major
+"@pydantic/otel-cf-workers": patch
+---
+
+Move the Cloudflare Worker OpenTelemetry implementation into the monorepo and publish Cloudflare packages as stable ESM-only packages.
+
+`@pydantic/logfire-cf-workers` now depends on the workspace `@pydantic/otel-cf-workers` package and no longer publishes CommonJS exports or `.d.cts` declarations. `@pydantic/otel-cf-workers` is published from this repository with unified OpenTelemetry catalog dependencies and ESM-only package exports.

AGENTS.md

@@ -11,6 +11,7 @@ This repository is the Pydantic Logfire JavaScript SDK monorepo. It provides Ope
 - `packages/logfire-api` publishes `logfire`, the core manual tracing API.
 - `packages/logfire-node` publishes `@pydantic/logfire-node`, which adds Node.js SDK setup and automatic instrumentation.
 - `packages/logfire-cf-workers` publishes `@pydantic/logfire-cf-workers`, which adapts Logfire to Cloudflare Workers.
+- `packages/otel-cf-workers` publishes `@pydantic/otel-cf-workers`, the lower-level Cloudflare Workers OpenTelemetry implementation used by the Logfire wrapper.
 - `packages/logfire-browser` publishes `@pydantic/logfire-browser`, which adapts Logfire to browser tracing.
 - `packages/tooling-config` contains shared build and lint configuration.
 - `examples/` contains runnable examples for Express, Next.js, Deno, Cloudflare Workers, browser usage, and related integrations.

docs/packages/cloudflare.md

@@ -73,6 +73,50 @@ import { instrument as instrumentFunction } from 'logfire'
 import { instrument as instrumentWorker } from '@pydantic/logfire-cf-workers'
 ```
 
+## Durable Objects
+
+Use `instrumentDO()` for Durable Object classes. It uses the same Logfire
+configuration path as `instrument()`, including `LOGFIRE_TOKEN`,
+`LOGFIRE_ENVIRONMENT`, `LOGFIRE_BASE_URL`, and scrubbing configuration.
+
+```ts
+import { instrument, instrumentDO } from '@pydantic/logfire-cf-workers'
+
+class CounterDurableObject implements DurableObject {
+  constructor(private state: DurableObjectState) {}
+
+  async fetch(): Promise<Response> {
+    const value = (await this.state.storage.get<number>('value')) ?? 0
+    await this.state.storage.put('value', value + 1)
+    return Response.json({ value })
+  }
+}
+
+export const Counter = instrumentDO(CounterDurableObject, {
+  service: {
+    name: 'counter-do',
+    namespace: '',
+    version: '1.0.0',
+  },
+})
+
+export default instrument(
+  {
+    async fetch(request, env): Promise<Response> {
+      const id = env.Counter.idFromName('global')
+      return env.Counter.get(id).fetch(request)
+    },
+  },
+  {
+    service: {
+      name: 'checkout-worker',
+      namespace: '',
+      version: '1.0.0',
+    },
+  }
+)
+```
+
 ## Tail Workers
 
 The package also supports Cloudflare Tail Worker flows:
@@ -94,12 +138,12 @@ This applies to both Logfire entrypoints:
   export.
 - `instrumentTail()` configures tail Worker export.
 
-Both entrypoints delegate to the underlying `@pydantic/otel-cf-workers`
-`instrument()` helper. That helper proxies the Worker execution context, tracks
-promises passed to `ctx.waitUntil()` inside the user handler, then schedules span
-export on the original context with `ctx.waitUntil()`. Export waits for a
-scheduler tick and the tracked promises before force-flushing the configured
-span processors.
+Both entrypoints use this repository's Cloudflare Worker OpenTelemetry
+instrumentation internally. The instrumentation proxies the Worker execution
+context, tracks promises passed to `ctx.waitUntil()` inside the user handler,
+then schedules span export on the original context with `ctx.waitUntil()`.
+Export waits for a scheduler tick and the tracked promises before force-flushing
+the configured span processors.
 
 Because export is tied to each Worker event, there is no long-lived Logfire
 runtime to shut down after deployment. Use `ctx.waitUntil()` for any asynchronous

examples/nextjs-bun/package.json

@@ -19,7 +19,7 @@
     "@opentelemetry/sdk-trace-web": "2.8.0",
     "@opentelemetry/semantic-conventions": "1.41.1",
     "@pydantic/logfire-browser": "0.16.3",
-    "@vercel/otel": "2.1.2",
+    "@vercel/otel": "2.1.3",
     "next": "16.2.7",
     "react": "19.2.7",
     "react-dom": "19.2.7"

packages/logfire-cf-workers/README.md

@@ -30,6 +30,28 @@ import { instrument as instrumentFunction } from 'logfire'
 import { instrument as instrumentWorker } from '@pydantic/logfire-cf-workers'
 ```
 
+Durable Object classes can be wrapped with `instrumentDO()` from this package so
+they use the same Logfire token, base URL, environment, and scrubbing
+configuration as Worker handlers.
+
+```ts
+import { instrumentDO } from '@pydantic/logfire-cf-workers'
+
+class CounterDurableObject implements DurableObject {
+  async fetch(): Promise<Response> {
+    return new Response('ok')
+  }
+}
+
+export const Counter = instrumentDO(CounterDurableObject, {
+  service: {
+    name: 'counter-do',
+    namespace: '',
+    version: '1.0.0',
+  },
+})
+```
+
 ## Runtime lifecycle
 
 Cloudflare Workers do not have a process-style shutdown hook. Logfire relies on
@@ -42,12 +64,12 @@ This applies to both Logfire entrypoints:
   export.
 - `instrumentTail()` configures tail Worker export.
 
-Both entrypoints delegate to the underlying `@pydantic/otel-cf-workers`
-`instrument()` helper. That helper proxies the Worker execution context, tracks
-promises passed to `ctx.waitUntil()` inside the user handler, then schedules span
-export on the original context with `ctx.waitUntil()`. Export waits for a
-scheduler tick and the tracked promises before force-flushing the configured span
-processors.
+Both entrypoints use this repository's Cloudflare Worker OpenTelemetry
+instrumentation internally. The instrumentation proxies the Worker execution
+context, tracks promises passed to `ctx.waitUntil()` inside the user handler,
+then schedules span export on the original context with `ctx.waitUntil()`.
+Export waits for a scheduler tick and the tracked promises before force-flushing
+the configured span processors.
 
 Because export is tied to each Worker event, there is no long-lived Logfire
 runtime to shut down after deployment. Use `ctx.waitUntil()` for any asynchronous

packages/logfire-cf-workers/package.json

@@ -28,19 +28,13 @@
   ],
   "version": "0.12.4",
   "type": "module",
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {
@@ -54,7 +48,7 @@
     "test": "vp test --passWithNoTests"
   },
   "dependencies": {
-    "@pydantic/otel-cf-workers": "^1.0.0-rc.56",
+    "@pydantic/otel-cf-workers": "workspace:*",
     "logfire": "workspace:*"
   },
   "devDependencies": {

packages/logfire-cf-workers/src/index.test.ts

@@ -1,5 +1,7 @@
+import { readdirSync, readFileSync } from 'node:fs'
 import { describe, expect, it } from 'vite-plus/test'
 import { instrument as instrumentFunction, startPendingSpan, withSettings, withTags } from 'logfire'
+import * as packageRoot from '@pydantic/logfire-cf-workers'
 
 import logfireCfWorkers, { instrument as instrumentWorker } from './index'
 
@@ -19,4 +21,19 @@ describe('cf-workers default export', () => {
     expect(logfireCfWorkers.withSettings).toBe(withSettings)
     expect(logfireCfWorkers.withTags).toBe(withTags)
   })
+
+  it('publishes esm-only package metadata', () => {
+    const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as {
+      exports: Record<string, Record<string, string>>
+    }
+
+    expect(packageRoot.instrument).toBeTypeOf('function')
+    expect(packageRoot.instrumentDO).toBeTypeOf('function')
+    expect(packageRoot.default.instrument).toBe(packageRoot.instrument)
+    expect(packageRoot.default.instrumentDO).toBe(packageRoot.instrumentDO)
+    expect(packageJson.exports['.']).not.toHaveProperty('require')
+    expect(packageJson.exports['.']?.['default']).toBe('./dist/index.js')
+    expect(packageJson.exports['.']?.['types']).toBe('./dist/index.d.ts')
+    expect(readdirSync(new URL('../dist', import.meta.url)).sort()).toEqual(['index.d.ts', 'index.js'])
+  })
 })

packages/logfire-cf-workers/src/index.ts

@@ -1,7 +1,7 @@
 import type { ReadableSpan, SpanProcessor } from '@opentelemetry/sdk-trace-base'
 import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
 import type { TraceConfig } from '@pydantic/otel-cf-workers'
-import { instrument as baseInstrument } from '@pydantic/otel-cf-workers'
+import { instrument as baseInstrument, instrumentDO as baseInstrumentDO } from '@pydantic/otel-cf-workers'
 import type { ScrubbingOptions } from 'logfire'
 import {
   configureLogfireApi,
@@ -34,7 +34,10 @@ import { LogfireCloudflareConsoleSpanExporter } from './LogfireCloudflareConsole
 import { TailWorkerExporter } from './TailWorkerExporter'
 export * from './exportTailEventsToLogfire'
 
-type Env = Record<string, string | undefined>
+type Env = unknown
+type LogfireEnv = Record<string, string | undefined>
+type WorkerHandler = ExportedHandler
+type DOClass<Env = unknown> = new (state: DurableObjectState, env: Env) => DurableObject
 
 type ConfigOptionsBase = Pick<
   TraceConfig,
@@ -60,11 +63,26 @@ export interface InProcessConfigOptions extends ConfigOptionsBase {
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface TailConfigOptions extends ConfigOptionsBase {}
 
+function envString(env: Env, key: string): string | undefined {
+  if (typeof env !== 'object' || env === null) {
+    return undefined
+  }
+  const value = (env as Record<string, unknown>)[key]
+  return typeof value === 'string' ? value : undefined
+}
+
+function configureScrubbing(config: InProcessConfigOptions): void {
+  if (config.scrubbing !== undefined) {
+    configureLogfireApi({ scrubbing: config.scrubbing })
+  }
+}
+
 function getInProcessConfig(config: InProcessConfigOptions): (env: Env) => TraceConfig {
   return (env: Env): TraceConfig => {
-    const { LOGFIRE_ENVIRONMENT: envDeploymentEnvironment, LOGFIRE_TOKEN: token = '' } = env
+    const token = envString(env, 'LOGFIRE_TOKEN') ?? ''
+    const envDeploymentEnvironment = envString(env, 'LOGFIRE_ENVIRONMENT')
 
-    const baseUrl = resolveBaseUrl(env, config.baseUrl, token)
+    const baseUrl = resolveBaseUrl(env as LogfireEnv, config.baseUrl, token)
     const resolvedEnvironment = config.environment ?? envDeploymentEnvironment
 
     const additionalSpanProcessors = config.additionalSpanProcessors ?? []
@@ -98,14 +116,17 @@ export function getTailConfig(config: TailConfigOptions): (env: Env) => TraceCon
 }
 
 export function instrumentInProcess<T>(handler: T, config: InProcessConfigOptions): T {
-  if (config.scrubbing !== undefined) {
-    configureLogfireApi({ scrubbing: config.scrubbing })
-  }
-  return baseInstrument(handler, getInProcessConfig(config)) as T
+  configureScrubbing(config)
+  return baseInstrument(handler as WorkerHandler, getInProcessConfig(config)) as T
+}
+
+export function instrumentDO<Env = unknown, T extends DOClass<Env> = DOClass<Env>>(doClass: T, config: InProcessConfigOptions): T {
+  configureScrubbing(config)
+  return baseInstrumentDO(doClass, getInProcessConfig(config)) as T
 }
 
 export function instrumentTail<T>(handler: T, config: TailConfigOptions): T {
-  return baseInstrument(handler, getTailConfig(config)) as T
+  return baseInstrument(handler as WorkerHandler, getTailConfig(config)) as T
 }
 
 /**
@@ -140,6 +161,7 @@ const defaultExport: {
   getTailConfig: typeof getTailConfig
   info: typeof info
   instrument: typeof instrument
+  instrumentDO: typeof instrumentDO
   instrumentInProcess: typeof instrumentInProcess
   instrumentTail: typeof instrumentTail
   log: typeof log
@@ -165,6 +187,7 @@ const defaultExport: {
   getTailConfig,
   info,
   instrument,
+  instrumentDO,
   instrumentInProcess,
   instrumentTail,
   // Re-export all from logfire

packages/logfire-cf-workers/src/vite-env.d.ts

@@ -1 +1,2 @@
 /// <reference types="vite/client" />
+/// <reference types="@cloudflare/workers-types" />

packages/logfire-cf-workers/vite.config.ts

@@ -1,17 +1,10 @@
-import { copyFileSync, existsSync } from 'node:fs'
 import { defineConfig } from 'vite-plus'
 
 const packageDefines = {
   PACKAGE_TIMESTAMP: String(Date.now()),
   PACKAGE_VERSION: JSON.stringify(process.env['npm_package_version'] ?? '0.0.0'),
 }
 
-const copyCjsDeclarations = () => {
-  if (existsSync('dist/index.d.ts')) {
-    copyFileSync('dist/index.d.ts', 'dist/index.d.cts')
-  }
-}
-
 const config: ReturnType<typeof defineConfig> = defineConfig({
   define: packageDefines,
   pack: {
@@ -23,14 +16,11 @@ const config: ReturnType<typeof defineConfig> = defineConfig({
       neverBundle: [/^@opentelemetry/u, /^node:/u, '@pydantic/otel-cf-workers', 'logfire'],
     },
     entry: 'src/index.ts',
-    format: ['esm', 'cjs'],
-    hooks: {
-      'build:done': copyCjsDeclarations,
-    },
+    format: ['esm'],
     minify: true,
-    outExtensions: ({ format }) => ({
-      dts: format === 'cjs' ? '.d.cts' : '.d.ts',
-      js: format === 'cjs' ? '.cjs' : '.js',
+    outExtensions: () => ({
+      dts: '.d.ts',
+      js: '.js',
     }),
     outputOptions: {
       exports: 'named',