loggily 0.3.0 → 0.4.0

package/src/worker.ts

@@ -42,7 +42,9 @@
 
 import {
   createLogger,
+  createSpanDataProxy,
   enableSpans,
+  writeSpan,
   type ConditionalLogger,
   type LazyMessage,
   type Logger,
@@ -319,8 +321,19 @@ export function createWorkerLogger(
         data: data ? { ...props, ...data } : Object.keys(props).length > 0 ? props : undefined,
         timestamp: Date.now(),
       })
-    } catch {
-      // Worker might be shutting down
+    } catch (err) {
+      // postMessage failed (e.g. uncloneable data) — send a diagnostic fallback
+      try {
+        postMessage({
+          type: "log",
+          level: "error",
+          namespace,
+          message: `postMessage failed for ${level} "${resolved}": ${err instanceof Error ? err.message : String(err)}`,
+          timestamp: Date.now(),
+        })
+      } catch {
+        // Worker might be shutting down — truly nothing we can do
+      }
     }
   }
 
@@ -348,37 +361,34 @@ export function createWorkerLogger(
         spanData: {},
         timestamp: Date.now(),
       })
-    } catch {
-      // Worker might be shutting down
+    } catch (err) {
+      // postMessage failed (e.g. uncloneable props) — send a diagnostic fallback
+      try {
+        postMessage({
+          type: "log",
+          level: "error",
+          namespace: fullNamespace,
+          message: `postMessage failed for span start "${fullNamespace}": ${err instanceof Error ? err.message : String(err)}`,
+          timestamp: Date.now(),
+        })
+      } catch {
+        // Worker might be shutting down
+      }
     }
 
     let ended = false
 
-    const spanData: SpanData = new Proxy(customSpanData as SpanData, {
-      get(_target, prop) {
-        if (prop === "id") return spanId
-        if (prop === "traceId") return spanTraceId
-        if (prop === "parentId") return parentSpanId
-        if (prop === "startTime") return startTime
-        if (prop === "endTime") return ended ? Date.now() : null
-        if (prop === "duration") return Date.now() - startTime
-        return customSpanData[prop as string]
-      },
-      set(_target, prop, value) {
-        if (
-          prop !== "id" &&
-          prop !== "traceId" &&
-          prop !== "parentId" &&
-          prop !== "startTime" &&
-          prop !== "endTime" &&
-          prop !== "duration"
-        ) {
-          customSpanData[prop as string] = value
-          return true
-        }
-        return false
-      },
-    })
+    const spanData: SpanData = createSpanDataProxy(
+      () => ({
+        id: spanId,
+        traceId: spanTraceId,
+        parentId: parentSpanId,
+        startTime,
+        endTime: ended ? Date.now() : null,
+        duration: Date.now() - startTime,
+      }),
+      customSpanData,
+    )
 
     function endSpan(): void {
       if (ended) return
@@ -402,8 +412,19 @@ export function createWorkerLogger(
           spanData: customSpanData,
           timestamp: Date.now(),
         })
-      } catch {
-        // Worker might be shutting down
+      } catch (err) {
+        // postMessage failed (e.g. uncloneable spanData) — send a diagnostic fallback
+        try {
+          postMessage({
+            type: "log",
+            level: "error",
+            namespace: fullNamespace,
+            message: `postMessage failed for span end "${fullNamespace}" (${duration}ms): ${err instanceof Error ? err.message : String(err)}`,
+            timestamp: Date.now(),
+          })
+        } catch {
+          // Worker might be shutting down
+        }
       }
     }
 
@@ -476,6 +497,60 @@ export interface WorkerConsoleHandlerOptions {
   logger?: Logger
 }
 
+/** Safely stringify a value, handling circular refs and BigInt */
+function safeStringify(value: unknown): string {
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return String(value)
+  }
+}
+
+/** Format console args into a message string and optional data object */
+function formatConsoleArgs(args: unknown[]): { message: string; data: Record<string, unknown> | undefined } {
+  const message =
+    args.length === 0
+      ? ""
+      : args.length === 1 && typeof args[0] === "string"
+        ? args[0]
+        : args.map((a) => (typeof a === "string" ? a : safeStringify(a))).join(" ")
+
+  const lastArg = args[args.length - 1]
+  const data =
+    args.length > 1 && typeof lastArg === "object" && lastArg !== null && !Array.isArray(lastArg)
+      ? (lastArg as Record<string, unknown>)
+      : undefined
+
+  return { message, data }
+}
+
+/** Dispatch a message to a logger at the given console level */
+function dispatchToLogger(
+  logger: ConditionalLogger,
+  level: "log" | "debug" | "info" | "warn" | "error" | "trace",
+  message: string,
+  data?: Record<string, unknown>,
+): void {
+  switch (level) {
+    case "trace":
+      logger.trace?.(message, data)
+      break
+    case "debug":
+      logger.debug?.(message, data)
+      break
+    case "info":
+    case "log":
+      logger.info?.(message, data)
+      break
+    case "warn":
+      logger.warn?.(message, data)
+      break
+    case "error":
+      logger.error?.(message, data)
+      break
+  }
+}
+
 /**
  * Create a handler for worker console messages.
  *
@@ -519,42 +594,8 @@ export function createWorkerConsoleHandler(
 
   return (message: WorkerConsoleMessage) => {
     const logger = getLogger(message.namespace)
-    const args = message.args
-
-    // Format args into a message string
-    const formattedMessage =
-      args.length === 0
-        ? ""
-        : args.length === 1 && typeof args[0] === "string"
-          ? args[0]
-          : args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" ")
-
-    // Extract data object if present (last arg is object and not a string)
-    const lastArg = args[args.length - 1]
-    const data =
-      args.length > 1 && typeof lastArg === "object" && lastArg !== null && !Array.isArray(lastArg)
-        ? (lastArg as Record<string, unknown>)
-        : undefined
-
-    // Log at the appropriate level (use ?. since level might be disabled)
-    switch (message.level) {
-      case "trace":
-        logger.trace?.(formattedMessage, data)
-        break
-      case "debug":
-        logger.debug?.(formattedMessage, data)
-        break
-      case "info":
-      case "log":
-        logger.info?.(formattedMessage, data)
-        break
-      case "warn":
-        logger.warn?.(formattedMessage, data)
-        break
-      case "error":
-        logger.error?.(formattedMessage, data)
-        break
-    }
+    const { message: msg, data } = formatConsoleArgs(message.args)
+    dispatchToLogger(logger, message.level, msg, data)
   }
 }
 
@@ -608,77 +649,23 @@ export function createWorkerLogHandler(options: WorkerLogHandlerOptions = {}): (
 
   return (message: WorkerMessage) => {
     if (isWorkerConsoleMessage(message)) {
-      // Handle console messages
       const logger = getLogger(message.namespace || "worker")
-      const args = message.args
-      const formattedMessage =
-        args.length === 0
-          ? ""
-          : args.length === 1 && typeof args[0] === "string"
-            ? args[0]
-            : args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" ")
-
-      const lastArg = args[args.length - 1]
-      const data =
-        args.length > 1 && typeof lastArg === "object" && lastArg !== null && !Array.isArray(lastArg)
-          ? (lastArg as Record<string, unknown>)
-          : undefined
-
-      // Use ?. since level might be disabled
-      switch (message.level) {
-        case "trace":
-          logger.trace?.(formattedMessage, data)
-          break
-        case "debug":
-          logger.debug?.(formattedMessage, data)
-          break
-        case "info":
-        case "log":
-          logger.info?.(formattedMessage, data)
-          break
-        case "warn":
-          logger.warn?.(formattedMessage, data)
-          break
-        case "error":
-          logger.error?.(formattedMessage, data)
-          break
-      }
+      const { message: msg, data } = formatConsoleArgs(message.args)
+      dispatchToLogger(logger, message.level, msg, data)
     } else if (isWorkerLogMessage(message)) {
-      // Handle structured log messages
       const logger = getLogger(message.namespace)
-
-      // Use ?. since level might be disabled
-      switch (message.level) {
-        case "trace":
-          logger.trace?.(message.message, message.data)
-          break
-        case "debug":
-          logger.debug?.(message.message, message.data)
-          break
-        case "info":
-          logger.info?.(message.message, message.data)
-          break
-        case "warn":
-          logger.warn?.(message.message, message.data)
-          break
-        case "error":
-          logger.error?.(message.message, message.data)
-          break
-      }
+      dispatchToLogger(logger, message.level, message.message, message.data)
     } else if (isWorkerSpanMessage(message)) {
       // Handle span events
-      // For span end events, create a span and immediately end it with the timing data
+      // For span end events, output the span with original worker timing data
       if (message.event === "end") {
-        const logger = getLogger(message.namespace)
-        const span = logger.span(undefined, message.props)
-
-        // Copy span data
-        for (const [key, value] of Object.entries(message.spanData)) {
-          span.spanData[key] = value
-        }
-
-        // End the span (this will output the span timing)
-        span.end()
+        writeSpan(message.namespace, message.duration ?? 0, {
+          span_id: message.spanId,
+          trace_id: message.traceId,
+          parent_id: message.parentId,
+          ...message.props,
+          ...message.spanData,
+        })
       }
       // Start events are informational only on main thread
       // (the actual timing happens in the worker)

package/.github/workflows/docs.yml

@@ -1,58 +0,0 @@
-name: Deploy Documentation
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - "docs/**"
-      - "src/**"
-      - ".github/workflows/docs.yml"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-concurrency:
-  group: pages
-  cancel-in-progress: false
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: Setup Pages
-        uses: actions/configure-pages@v4
-
-      - name: Install dependencies
-        run: bun install
-
-      - name: Build docs
-        run: bun run docs:build
-
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: docs/site/.vitepress/dist
-
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

package/.github/workflows/release.yml

@@ -1,31 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-permissions:
-  contents: write
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-      - run: bun install
-      - run: bun test
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-          registry-url: 'https://registry.npmjs.org'
-      - run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-      - name: Create GitHub Release
-        uses: softprops/action-gh-release@v2
-        with:
-          generate_release_notes: true

package/.github/workflows/test.yml

@@ -1,20 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-      - run: bun install
-      - run: bun run typecheck
-      - run: bun test

package/CHANGELOG.md

@@ -1,45 +0,0 @@
-# Changelog
-
-All notable changes to loggily will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.2.0] - 2026-03-04
-
-### Added
-
-- **Lazy messages** -- Pass `() => string` functions that are only called when the level is enabled
-- **Child context loggers** -- `log.child({ requestId: "abc" })` creates a logger with structured context fields in every message
-- **LOG_FORMAT env var** -- `LOG_FORMAT=json` explicitly enables structured JSON output
-- `setLogFormat()` / `getLogFormat()` -- Programmatic log format control
-- `setDebugFilter()` / `getDebugFilter()` -- Programmatic namespace filtering (like `DEBUG` env var)
-- **File writer** -- `createFileWriter(path, opts?)` for buffered file output with auto-flush
-- **Writer system** -- `addWriter(fn)` to subscribe to all formatted log output
-- `setOutputMode()` / `getOutputMode()` -- Control output destination (`console`, `stderr`, `writers-only`)
-- `setSuppressConsole()` -- Suppress console output while writers still receive
-- Comprehensive test suite (153 tests)
-
-### Changed
-
-- `createLogger()` now returns a `ConditionalLogger` directly (no separate function needed)
-- Improved documentation with full API reference and comparison guides
-
-## [0.1.0] - 2026-01-15
-
-### Added
-
-- Initial release
-- `createLogger(name, props?)` -- Create structured logger
-- Logger methods: `trace`, `debug`, `info`, `warn`, `error`
-- Child loggers with `.logger(namespace, props?)`
-- Span timing with `.span(namespace, props?)` and `using` keyword support
-- `SpanData` with id, traceId, parentId, startTime, endTime, duration
-- Custom span attributes via `span.spanData.key = value`
-- Configuration via environment variables: `LOG_LEVEL`, `TRACE`, `TRACE_FORMAT`
-- Programmatic configuration: `setLogLevel`, `getLogLevel`, `enableSpans`, `disableSpans`, `spansAreEnabled`
-- `setTraceFilter()` / `getTraceFilter()` -- Namespace-based span output control
-- Dual output format: pretty console (dev) and JSON (production)
-- Worker thread support: `createWorkerLogger`, `createWorkerLogHandler`, `forwardConsole`
-- Span collection for testing: `startCollecting`, `stopCollecting`, `getCollectedSpans`, `clearCollectedSpans`
-- `resetIds()` for deterministic tests