@polygonlabs/logger 0.2.0 → 0.3.0

package/README.md

@@ -1,7 +1,7 @@
 # @polygonlabs/logger
 
 Shared pino-based logger for Polygon Apps Team services. Pre-configured for Datadog
-ingestion with VError-aware error logging and optional Sentry capture.
+ingestion with automatic VError-aware error handling and optional Sentry capture.
 
 ## Why this package exists
 
@@ -10,8 +10,9 @@ Every service in the team needs the same pino configuration: `message` key inste
 in each service individually leads to drift — one service logs `"msg"` while another logs
 `"message"`, breaking Datadog log parsing.
 
-This package provides one factory, one type, and a consistent output shape across all
-services.
+This package provides one factory and a consistent output shape across all services.
+VError/WError handling and Sentry capture are wired in at the pino level, so every log
+call benefits automatically — no special method required.
 
 ## Usage
 
@@ -20,7 +21,7 @@ import { createLogger } from '@polygonlabs/logger';
 
 const logger = await createLogger();
 logger.info({ requestId: '123' }, 'request received');
-logger.logError({ err });
+logger.error({ err }, err.message);
 ```
 
 **Do not import as a module-level singleton.** Construct once at the service entry point
@@ -34,7 +35,7 @@ const logger = await createLogger({ sentry });
 
 // handler / service layer
 class UserService {
-  constructor(private readonly logger: AppLogger) {}
+  constructor(private readonly logger: Logger) {}
 
   async getUser(id: string) {
     const log = this.logger.child({ userId: id });
@@ -43,6 +44,8 @@ class UserService {
 }
 ```
 
+`createLogger` returns pino's `Logger` type directly — import it from `pino`.
+
 ## Customisation via child loggers
 
 `createLogger()` intentionally does not accept options for the output shape — that
@@ -84,84 +87,48 @@ const httpLogger = logger.child(
 **Request/handler-scoped fields** — create further children inside handlers:
 
 ```ts
-async function handleRequest(req: Request, logger: AppLogger) {
+async function handleRequest(req: Request, logger: Logger) {
   const log = logger.child({ requestId: req.id, method: req.method });
-  log.info('handling request');   // { service, env, requestId, method, message }
-  log.logError({ err });          // { service, env, requestId, method, err, message }
+  log.info('handling request');
+  log.error({ err }, err.message);
 }
 ```
 
 Child bindings and options merge at any depth — grandchild loggers carry all ancestor
-bindings, and `logError` and `child()` are preserved at every level.
-
-## `AppLogger` type
-
-`AppLogger` is a standard `pino.Logger` with two additions:
-
-- **`logError({ err, ...context }, message?)`** — VError/WError-aware error logging (see below)
-- **`child()`** — overridden to return `AppLogger` so child loggers carry `logError`
-  at any depth
-
-Use `AppLogger` as the type throughout your service code rather than importing
-`createLogger` everywhere.
+bindings, and all VError/WError behaviour is preserved at every level.
 
-## `logError({ err, ...context }, message?)`
+## VError and WError handling
 
-`logError` is the only method `AppLogger` adds to the standard pino API. Its signature
-mirrors pino's merge-object form with `err` as a required key:
+VError/WError handling is automatic for every log level. Pass `err` in the merge object
+as you would any other pino log call:
 
 ```ts
-try {
-  await db.query(sql);
-} catch (err) {
-  logger.logError({ err });
-  logger.logError({ err, requestId, userId });                  // with call-site context
-  logger.logError({ err, requestId }, 'user-facing message');   // with message override
-}
+logger.error({ err }, err.message)
+logger.warn({ err, requestId }, 'degraded — retrying')
+logger.error({ err, requestId, userId }, 'optional message override')
 ```
 
-Any fields beyond `err` are merged into the log entry at the top level, exactly as they
-would be if you called `logger.error({ err, requestId }, message)` directly. All entries
-carry the child bindings of the logger and are always at `error` level.
-
-`err` must be an `Error` instance — passing a non-Error is a TypeScript error. For unknown
-values from a catch block, narrow first or fall back to `logger.error()` directly:
-
-```ts
-try {
-  await something();
-} catch (err) {
-  if (err instanceof Error) {
-    logger.logError({ err });
-  } else {
-    logger.error(String(err));
-  }
-}
-```
-
-### VError `info` is namespaced under `"error_info"`
+### `error_info`
 
 VError `info` fields from the full cause chain are always emitted under the reserved
 `error_info` key — never spread at the top level. This keeps error-carried context clearly
-separated from call-site context, with no collision risk and no precedence rules to remember:
+separated from call-site context, with no collision risk:
 
 ```ts
 const err = new VError('query failed', { info: { requestId: 'abc', table: 'users' } });
-logger.logError({ err, traceId: 'xyz' });
-// { level: 'error', message: 'query failed', err: { ... },
-//   traceId: 'xyz',                               ← call-site context, top level
+logger.error({ err, traceId: 'xyz' }, err.message);
+// {
+//   level: 'error', message: 'query failed', err: { ... },
+//   traceId: 'xyz',                                  ← call-site context, top level
 //   error_info: { requestId: 'abc', table: 'users' } ← error info, always nested
 // }
 ```
 
-`error_info` is a **reserved key** in the context object — passing it is a TypeScript error:
+If a VError has no `info`, the `error_info` key is omitted entirely.
 
-```ts
-logger.logError({ err, error_info: { foo: 'bar' } });
-//                     ^^^^^^^^^^ TypeScript error: error_info is not assignable to never
-```
-
-If a VError has no `info`, the `error_info` key is omitted from the log entry entirely.
+`error_info` is a **reserved key** — do not include it in merge objects. If a caller
+supplies it, the logger emits a `warn`-level diagnostic with the conflicting value under
+`callerErrorInfo`, then overwrites the key with the real VError info.
 
 ### Behaviour by `err` type
 
@@ -169,7 +136,7 @@ If a VError has no `info`, the `error_info` key is omitted from the log entry en
 `stdSerializers.err`) and the error message as the log message. No `error_info` key:
 
 ```ts
-logger.logError({ err: new Error('connection refused') });
+logger.error({ err: new Error('connection refused') }, 'connection refused');
 // { level: 'error', message: 'connection refused', err: { message, stack, type } }
 ```
 
@@ -177,7 +144,7 @@ logger.logError({ err: new Error('connection refused') });
 
 ```ts
 const err = new VError('query failed', { info: { requestId: 'abc', table: 'users' } });
-logger.logError({ err });
+logger.error({ err }, err.message);
 // { level: 'error', message: 'query failed', err: { ... }, error_info: { requestId: 'abc', table: 'users' } }
 ```
 
@@ -187,19 +154,22 @@ context is carried through to the cause's entry:
 ```ts
 const root = new Error('connection refused');
 const err = new WError('could not load user', { cause: root });
-logger.logError({ err, requestId: 'abc' });
+logger.error({ err, requestId: 'abc' }, err.message);
 // { level: 'error', message: 'connection refused', err: { ... }, requestId: 'abc' }
 // 'could not load user' is NOT logged — the cause is what matters
 ```
 
 The cause is processed by the same rules, so a `WError` wrapping a `VError` with `info`
-will emit the `VError` entry with `info` nested and call-site context at the top level.
+will emit the `VError`'s `error_info` alongside call-site context.
+
+## Sentry
 
-### Sentry
+If a Sentry client was passed to `createLogger`, `captureException` fires automatically
+for every `logger.error({ err })` call. It does not fire for `warn`, `info`, or other
+levels — only `error`.
 
-If a Sentry client was passed to `createLogger`, `logError` captures alongside the pino
-entries: `captureException` for `Error` instances, `captureMessage` for non-Error values.
-For a `WError`, only the cause is captured — consistent with the logging behaviour above.
+For a `WError`, the cause is captured rather than the wrapper, consistent with what is
+logged.
 
 ```ts
 import * as Sentry from '@sentry/node';
@@ -232,6 +202,12 @@ The logger is pre-configured for Datadog ingestion:
 | `pid`, `hostname` | suppressed |
 | `err` | serialised via pino's built-in `stdSerializers.err` |
 
-Passing a `timestamp` key in a merge object is detected and renamed to `callerTimestamp`
-with a warning. Letting caller-supplied timestamps shadow the authoritative timestamp
-causes Datadog to sort log entries incorrectly.
+### Reserved keys
+
+Two keys in the merge object are reserved and will trigger a `warn`-level diagnostic if
+supplied by a caller:
+
+| Key | Written by | Conflicting value preserved as |
+|-----|-----------|-------------------------------|
+| `timestamp` | `timestamp` function | `callerTimestamp` |
+| `error_info` | VError info extractor | `callerErrorInfo` |

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { createLogger } from './logger.ts';
-export type { AppLogger, CreateLoggerOptions, SentryAdapter } from './logger.ts';
+export type { CreateLoggerOptions, SentryAdapter } from './logger.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EAAE,SAAS,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}

package/dist/logger.d.ts

@@ -1,60 +1,13 @@
-import type { Bindings, ChildLoggerOptions, DestinationStream, Logger } from 'pino';
+import type { DestinationStream, Logger } from 'pino';
 /**
  * Duck-typed interface for Sentry error capturing. Matches the surface of
- * @sentry/node used by logError. Pass an initialised Sentry client to
- * createLogger to activate automatic error capture alongside pino logging.
+ * @sentry/node used by automatic error capture on logger.error() calls. Pass
+ * an initialised Sentry client to createLogger to activate it.
  */
 export interface SentryAdapter {
     captureException(err: unknown): void;
     captureMessage(msg: string, level: string): void;
 }
-/**
- * pino Logger extended with logError and a narrowed child() return type.
- *
- * logError is a VError/WError-aware error logging helper: use it in preference
- * to logger.error() for caught exceptions so that VError info fields are emitted
- * as discrete structured fields and WError cause chains are fully unwound into
- * separate log entries.
- *
- * child() is overridden to return AppLogger so child loggers inherit logError
- * and the override is preserved at any depth.
- *
- * Inject this type throughout your service rather than importing a module-level
- * singleton. Construct once at the entry point and pass down via constructor
- * arguments or function parameters.
- */
-export type AppLogger = Omit<Logger, 'child'> & {
-    /**
-     * Log an error at `error` level. Mirrors pino's merge-object signature with
-     * `err` as a required key:
-     *
-     *   logger.logError({ err })
-     *   logger.logError({ err, requestId, userId }, 'optional message override')
-     *
-     * VError `info` fields from the full cause chain are spread into the log entry
-     * alongside any call-site context. Call-site context wins on key collision.
-     * WError wrappers are skipped — only the cause is logged.
-     */
-    /**
-     * Log an error at `error` level. Mirrors pino's merge-object signature with
-     * `err` as a required key:
-     *
-     *   logger.logError({ err })
-     *   logger.logError({ err, requestId, userId }, 'optional message override')
-     *
-     * VError `info` from the full cause chain is always emitted under the `error_info`
-     * key — never spread at the top level. This means `error_info` is a reserved key:
-     * passing it in the context object is a TypeScript error.
-     *
-     * `err` must be an `Error` instance. For non-Error caught values, narrow first or
-     * use `logger.error()` directly.
-     */
-    logError(obj: {
-        err: Error;
-        error_info?: never;
-    } & Record<string, unknown>, message?: string): void;
-    child(bindings: Bindings, options?: ChildLoggerOptions): AppLogger;
-};
 export interface CreateLoggerOptions {
     /** Enable pino-pretty output for development. Requires pino-pretty to be installed. */
     pretty?: boolean;
@@ -64,11 +17,11 @@ export interface CreateLoggerOptions {
      */
     destination?: DestinationStream;
     /**
-     * Optional Sentry adapter for automatic error capturing in logError.
+     * Optional Sentry adapter for automatic error capturing on logger.error() calls.
      * Pass your initialised @sentry/node instance (or any object satisfying
-     * SentryAdapter). Propagated automatically to all child loggers.
+     * SentryAdapter). Inherited by all child loggers.
      */
     sentry?: SentryAdapter;
 }
-export declare function createLogger(options?: CreateLoggerOptions): Promise<AppLogger>;
+export declare function createLogger(options?: CreateLoggerOptions): Promise<Logger>;
 //# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAMnG;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IACrC,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAClD;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC9C;;;;;;;;;;OAUG;IACH;;;;;;;;;;;;;OAaG;IACH,QAAQ,CACN,GAAG,EAAE;QAAE,GAAG,EAAE,KAAK,CAAC;QAAC,UAAU,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjE,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAAC;IACR,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;CACpE,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,uFAAuF;IACvF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC;;;;OAIG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAmCD,wBAAsB,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,CAAC,CA2FpF"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAMrE;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IACrC,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAClD;AAED,MAAM,WAAW,mBAAmB;IAClC,uFAAuF;IACvF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC;;;;OAIG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAKD,wBAAsB,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAiGjF"}

package/dist/logger.js

@@ -1,25 +1,7 @@
 import { pino, stdSerializers } from 'pino';
 import { VError, WError } from '@polygonlabs/verror';
-function logError(logger, obj, message, sentry) {
-    const { err, ...context } = obj;
-    // WError is a wrapper whose own message is intentionally not the useful signal —
-    // the cause is. Skip the WError itself and recurse directly into its cause.
-    // Carry call-site context through; discard the developer's message override since
-    // it described the wrapper, not the cause.
-    if (err instanceof WError) {
-        const cause = VError.cause(err);
-        // The spread of context (Record<string, unknown>) widens err back to unknown;
-        // cast is safe because cause is narrowed to Error by the if-guard above.
-        if (cause)
-            logError(logger, { err: cause, ...context }, undefined, sentry);
-        return;
-    }
-    // info from the full cause chain is spread first so call-site context wins on collision.
-    const info = err instanceof VError ? VError.info(err) : {};
-    const infoEntry = Object.keys(info).length > 0 ? { error_info: info } : {};
-    logger.error({ err, ...context, ...infoEntry }, message ?? err.message);
-    sentry?.captureException(err);
-}
+// Pino's numeric level for "error". Used in hooks.logMethod to gate Sentry capture.
+const PINO_ERROR_LEVEL = 50;
 export async function createLogger(options) {
     // ref.self is assigned immediately after pino() returns. The formatters.log
     // closure only fires when a log method is called — never during construction —
@@ -41,19 +23,56 @@ export async function createLogger(options) {
             level(label) {
                 return { level: label };
             },
-            // Detect a caller-supplied "timestamp" key and rename it so it cannot
-            // shadow the authoritative timestamp written by the timestamp function.
             log(object) {
-                if ('timestamp' in object) {
-                    const { timestamp, ...rest } = object;
+                let out = object;
+                // Detect a caller-supplied "timestamp" key and rename it so it cannot
+                // shadow the authoritative timestamp written by the timestamp function.
+                if ('timestamp' in out) {
+                    const { timestamp, ...rest } = out;
                     ref.self?.warn({ callerTimestamp: timestamp }, 'Log call included "timestamp" in merge object — reserved key renamed to callerTimestamp. Fix the call site.');
-                    return { callerTimestamp: timestamp, ...rest };
+                    out = { callerTimestamp: timestamp, ...rest };
+                }
+                // Detect a caller-supplied "error_info" key and strip it — the correct
+                // value is derived from the err below. Preserve the caller's value in a
+                // warning so it is not silently lost.
+                if ('error_info' in out) {
+                    const { error_info, ...rest } = out;
+                    ref.self?.warn({ callerErrorInfo: error_info }, 'Log call included "error_info" in merge object — reserved key ignored. Fix the call site.');
+                    out = rest;
                 }
-                return object;
+                // Emit merged VError info chain under error_info for structured querying.
+                // By this point hooks.logMethod has already unwrapped any WError, so err
+                // is always the meaningful cause when it arrives here.
+                if (out['err'] instanceof VError) {
+                    const info = VError.info(out['err']);
+                    if (Object.keys(info).length > 0)
+                        out = { ...out, error_info: info };
+                }
+                return out;
             }
         },
         serializers: {
             err: stdSerializers.err
+        },
+        hooks: {
+            logMethod(args, method, level) {
+                const first = args[0];
+                if (first !== null && typeof first === 'object' && 'err' in first) {
+                    const obj = first;
+                    if (obj['err'] instanceof Error) {
+                        // Unwrap WError chain — WError's own message is never the useful signal.
+                        let err = obj['err'];
+                        while (err instanceof WError)
+                            err = VError.cause(err) ?? err;
+                        if (err !== obj['err'])
+                            args[0] = { ...obj, err };
+                        // Capture in Sentry for error-level calls only.
+                        if (level === PINO_ERROR_LEVEL)
+                            options?.sentry?.captureException(err);
+                    }
+                }
+                method.apply(this, args);
+            }
         }
     };
     let destination = options?.destination;
@@ -67,32 +86,7 @@ export async function createLogger(options) {
         });
     }
     const base = destination ? pino(pinoOptions, destination) : pino(pinoOptions);
-    // Capture child from Logger.prototype directly rather than from the instance, so we
-    // hold a reference to the prototype method that cannot be shadowed by an own property.
-    // We call it with .call(target) where target is the raw pino instance (never the Proxy),
-    // so pino's child creation runs with a clean `this` and produces a raw child whose
-    // prototype chain is pure pino. We then wrap that child in a new Proxy via enrichLogger.
-    const pinoProtoChild = Object.getPrototypeOf(base).child;
-    function enrichLogger(instance) {
-        // Wrap in a Proxy rather than mutating the pino logger instance. Mutation would
-        // make logError and child OWN properties on the pino object, which become visible
-        // in descendant loggers via their prototype chain (pino creates children with
-        // Object.create(parent)). A Proxy intercepts only the two properties we care about
-        // and passes everything else through to the original logger untouched.
-        return new Proxy(instance, {
-            get(target, prop, receiver) {
-                if (prop === 'logError') {
-                    return (obj, message) => logError(target, obj, message, options?.sentry);
-                }
-                if (prop === 'child') {
-                    return (bindings, childOptions) => enrichLogger(pinoProtoChild.call(target, bindings, childOptions));
-                }
-                return Reflect.get(target, prop, receiver);
-            }
-        });
-    }
-    const logger = enrichLogger(base);
-    ref.self = logger;
-    return logger;
+    ref.self = base;
+    return base;
 }
 //# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polygonlabs/logger",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Pino-based logger with Sentry integration, configured for Datadog ingestion and prettified output capable.",
   "type": "module",
   "repository": {