feat(module): add Cloudflare Workers adapter

- Add initWorkersLogger() and createWorkersLogger() for CF Workers
- Auto-extract cf-ray as requestId, request.cf context (colo, country, asn)
- Add stringify option to skip JSON.stringify for Workers platform
- Fix process undefined in Workers env detection (isDev returns false)
- Simplify getConsoleMethod to identity function

Author: dmmulroy

README.md

@@ -350,6 +350,49 @@ async function processSyncJob(job: Job) {
 }
 ```
 
+## Cloudflare Workers
+
+Use the Workers adapter for structured logs and correct platform severity.
+
+```typescript
+// src/index.ts
+import { initWorkersLogger, createWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'edge-api' },
+})
+
+export default {
+  async fetch(request: Request) {
+    const log = createWorkersLogger(request)
+
+    try {
+      log.set({ route: 'health' })
+      const response = new Response('ok', { status: 200 })
+      log.emit({ status: response.status })
+      return response
+    } catch (error) {
+      log.error(error as Error)
+      log.emit({ status: 500 })
+      throw error
+    }
+  },
+}
+```
+
+Disable invocation logs to avoid duplicate request logs:
+
+```toml
+# wrangler.toml
+[observability.logs]
+invocation_logs = false
+```
+
+Notes:
+- `requestId` defaults to `cf-ray` when available
+- `request.cf` is included (colo, country, asn) unless disabled
+- Use `headerAllowlist` to avoid logging sensitive headers
+
 ## API Reference
 
 ### `initLogger(config)`
@@ -366,6 +409,7 @@ initLogger({
     region?: string      // Deployment region
   },
   pretty?: boolean       // Pretty print (default: true in dev)
+  stringify?: boolean    // JSON.stringify output (default: true, false for Workers)
   include?: string[]     // Route patterns to log (glob), e.g. ['/api/**']
   sampling?: {
     rates?: {
@@ -437,6 +481,34 @@ log.emit()                         // Emit final event
 log.getContext()                   // Get current context
 ```
 
+### `initWorkersLogger(options?)`
+
+Initialize evlog for Cloudflare Workers (object logs + correct severity).
+
+```typescript
+import { initWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'edge-api' },
+})
+```
+
+### `createWorkersLogger(request, options?)`
+
+Create a request-scoped logger for Workers. Auto-extracts `cf-ray`, `request.cf`, method, and path.
+
+```typescript
+import { createWorkersLogger } from 'evlog/workers'
+
+const log = createWorkersLogger(request, {
+  requestId: 'custom-id',      // Override cf-ray (default: cf-ray header)
+  headers: ['x-request-id'],   // Headers to include (default: none)
+})
+
+log.set({ user: { id: '123' } })
+log.emit({ status: 200 })
+```
+
 ### `createError(options)`
 
 Create a structured error with HTTP status support. Import from `evlog` directly to avoid conflicts with Nuxt/Nitro's `createError`.

apps/docs/content/1.getting-started/2.installation.md

@@ -3,7 +3,7 @@ title: Installation
 description: Install evlog in your Nuxt, Nitro, or standalone TypeScript project.
 ---
 
-evlog supports multiple environments: Nuxt, Nitro, and standalone TypeScript.
+evlog supports multiple environments: Nuxt, Nitro, Cloudflare Workers, and standalone TypeScript.
 
 ## Nuxt
 
@@ -259,6 +259,47 @@ export default defineNitroConfig({
 })
 ```
 
+## Cloudflare Workers
+
+Use the Workers adapter for structured logs and correct platform severity.
+
+```typescript [src/index.ts]
+import { initWorkersLogger, createWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'edge-api' },
+})
+
+export default {
+  async fetch(request: Request) {
+    const log = createWorkersLogger(request)
+
+    try {
+      log.set({ route: 'health' })
+      const response = new Response('ok', { status: 200 })
+      log.emit({ status: response.status })
+      return response
+    } catch (error) {
+      log.error(error as Error)
+      log.emit({ status: 500 })
+      throw error
+    }
+  },
+}
+```
+
+Disable invocation logs to avoid duplicate request logs:
+
+```toml [wrangler.toml]
+[observability.logs]
+invocation_logs = false
+```
+
+Notes:
+- `requestId` defaults to `cf-ray` when available
+- `request.cf` is included (colo, country, asn) unless disabled
+- Use `headerAllowlist` to avoid logging sensitive headers
+
 ## Standalone TypeScript
 
 Install evlog via your preferred package manager:

bun.lock

@@ -0,0 +1,8 @@
+# Cloudflare Workers Example
+
+```bash
+pnpm add evlog
+pnpm dlx wrangler dev
+```
+
+This example uses `evlog/workers` and disables invocation logs to avoid duplicate request logs.

examples/workers/README.md

@@ -0,0 +1,22 @@
+import { initWorkersLogger, createWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'workers-example' },
+})
+
+export default {
+  async fetch(request: Request) {
+    const log = createWorkersLogger(request)
+
+    try {
+      log.set({ route: 'health' })
+      const response = new Response('ok', { status: 200 })
+      log.emit({ status: response.status })
+      return response
+    } catch (error) {
+      log.error(error as Error)
+      log.emit({ status: 500 })
+      throw error
+    }
+  },
+}

examples/workers/src/index.ts

@@ -0,0 +1,7 @@
+name = "evlog-workers-example"
+main = "src/index.ts"
+compatibility_date = "2026-02-03"
+
+[observability.logs]
+enabled = true
+invocation_logs = false

examples/workers/wrangler.toml

@@ -346,6 +346,49 @@ async function processSyncJob(job: Job) {
 }
 ```
 
+## Cloudflare Workers
+
+Use the Workers adapter for structured logs and correct platform severity.
+
+```typescript
+// src/index.ts
+import { initWorkersLogger, createWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'edge-api' },
+})
+
+export default {
+  async fetch(request: Request) {
+    const log = createWorkersLogger(request)
+
+    try {
+      log.set({ route: 'health' })
+      const response = new Response('ok', { status: 200 })
+      log.emit({ status: response.status })
+      return response
+    } catch (error) {
+      log.error(error as Error)
+      log.emit({ status: 500 })
+      throw error
+    }
+  },
+}
+```
+
+Disable invocation logs to avoid duplicate request logs:
+
+```toml
+# wrangler.toml
+[observability.logs]
+invocation_logs = false
+```
+
+Notes:
+- `requestId` defaults to `cf-ray` when available
+- `request.cf` is included (colo, country, asn) unless disabled
+- Use `headerAllowlist` to avoid logging sensitive headers
+
 ## API Reference
 
 ### `initLogger(config)`
@@ -362,6 +405,7 @@ initLogger({
     region?: string      // Deployment region
   },
   pretty?: boolean       // Pretty print (default: true in dev)
+  stringify?: boolean    // JSON.stringify output (default: true, false for Workers)
   include?: string[]     // Route patterns to log (glob), e.g. ['/api/**']
   sampling?: {
     rates?: {            // Head sampling (random per level)
@@ -479,6 +523,34 @@ log.emit()                         // Emit final event
 log.getContext()                   // Get current context
 ```
 
+### `initWorkersLogger(options?)`
+
+Initialize evlog for Cloudflare Workers (object logs + correct severity).
+
+```typescript
+import { initWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'edge-api' },
+})
+```
+
+### `createWorkersLogger(request, options?)`
+
+Create a request-scoped logger for Workers. Auto-extracts `cf-ray`, `request.cf`, method, and path.
+
+```typescript
+import { createWorkersLogger } from 'evlog/workers'
+
+const log = createWorkersLogger(request, {
+  requestId: 'custom-id',      // Override cf-ray (default: cf-ray header)
+  headers: ['x-request-id'],   // Headers to include (default: none)
+})
+
+log.set({ user: { id: '123' } })
+log.emit({ status: 200 })
+```
+
 ### `createError(options)`
 
 Create a structured error with HTTP status support. Import from `evlog` directly to avoid conflicts with Nuxt/Nitro's `createError`.

packages/evlog/README.md

@@ -14,6 +14,7 @@ export default defineBuildConfig({
     { input: 'src/logger', name: 'logger' },
     { input: 'src/utils', name: 'utils' },
     { input: 'src/types', name: 'types' },
+    { input: 'src/workers/index', name: 'workers' },
   ],
   declaration: true,
   clean: true,

packages/evlog/build.config.ts

@@ -34,6 +34,10 @@
     "./nitro": {
       "types": "./dist/nitro/plugin.d.mts",
       "import": "./dist/nitro/plugin.mjs"
+    },
+    "./workers": {
+      "types": "./dist/workers.d.mts",
+      "import": "./dist/workers.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -48,6 +52,9 @@
       ],
       "nitro": [
         "./dist/nitro/plugin.d.mts"
+      ],
+      "workers": [
+        "./dist/workers.d.mts"
       ]
     }
   },

packages/evlog/package.json

@@ -9,6 +9,7 @@ let globalEnv: EnvironmentContext = {
 
 let globalPretty = isDev()
 let globalSampling: SamplingConfig = {}
+let globalStringify = true
 
 /**
  * Initialize the logger with configuration.
@@ -27,6 +28,7 @@ export function initLogger(config: LoggerConfig = {}): void {
 
   globalPretty = config.pretty ?? isDev()
   globalSampling = config.sampling ?? {}
+  globalStringify = config.stringify ?? true
 }
 
 /**
@@ -87,8 +89,10 @@ function emitWideEvent(level: LogLevel, event: Record<string, unknown>, skipSamp
 
   if (globalPretty) {
     prettyPrintWideEvent(formatted)
-  } else {
+  } else if (globalStringify) {
     console[getConsoleMethod(level)](JSON.stringify(formatted))
+  } else {
+    console[getConsoleMethod(level)](formatted)
   }
 
   return formatted
@@ -102,9 +106,9 @@ function emitTaggedLog(level: LogLevel, tag: string, message: string): void {
     const color = getLevelColor(level)
     const timestamp = new Date().toISOString().slice(11, 23)
     console.log(`${colors.dim}${timestamp}${colors.reset} ${color}[${tag}]${colors.reset} ${message}`)
-  } else {
-    emitWideEvent(level, { tag, message })
+    return
   }
+  emitWideEvent(level, { tag, message })
 }
 
 function formatValue(value: unknown): string {