widelogger 0.3.0 → 0.5.0

package/README.md

@@ -104,12 +104,11 @@ import { widelog } from "widelogger";
 export const checkout = async (request, response) => {
   const { userId } = request.body;
 
-  widelog.set("user.id", userId);
-  widelog.set("user.plan", "premium");
+  widelog.setFields({ user: { id: userId, plan: "premium" } });
 
-  widelog.time.start("db_ms");
-  const order = await processOrder(userId);
-  widelog.time.stop("db_ms");
+  const order = await widelog.time.measure("db_ms", () =>
+    processOrder(userId),
+  );
 
   widelog.set("order.total_cents", order.totalCents);
   widelog.count("order.items", order.itemCount);
@@ -141,12 +140,11 @@ import { widelog } from "widelogger";
 export const checkout = async (request: Request) => {
   const { userId } = await request.json();
 
-  widelog.set("user.id", userId);
-  widelog.set("user.plan", "premium");
+  widelog.setFields({ user: { id: userId, plan: "premium" } });
 
-  widelog.time.start("db_ms");
-  const order = await processOrder(userId);
-  widelog.time.stop("db_ms");
+  const order = await widelog.time.measure("db_ms", () =>
+    processOrder(userId),
+  );
 
   widelog.set("order.total_cents", order.totalCents);
   widelog.count("order.items", order.itemCount);
@@ -202,6 +200,31 @@ widelog.set("user.plan", "premium");
 // Output: { user: { id: "usr_123", plan: "premium" } }
 ```
 
+### Bulk Fields
+
+`setFields` accepts a nested object and recursively flattens it into individual `set` calls. Non-primitive values (other than plain objects) are silently ignored.
+
+```ts
+widelog.setFields({
+  user: { id: "usr_123", plan: "premium" },
+  status_code: 200,
+});
+// Equivalent to:
+// widelog.set("user.id", "usr_123");
+// widelog.set("user.plan", "premium");
+// widelog.set("status_code", 200);
+```
+
+### Measured Timing
+
+`time.measure` wraps a sync or async callback, automatically recording start and stop times. It returns the callback's result and still records timing even if the callback throws.
+
+```ts
+const order = await widelog.time.measure("db_ms", () =>
+  processOrder(userId),
+);
+```
+
 ### Log Routing
 
 Events with `status_code >= 500` or `outcome === "error"` are emitted at `error` level. Everything else is `info`. In development, logs are pretty-printed; in production, they're structured JSON.
@@ -233,12 +256,14 @@ Imported directly from `"widelogger"`. All methods operate on the current async
 | Method | Description |
 |--------|-------------|
 | `set(key, value)` | Set a field value (last write wins) |
+| `setFields(fields)` | Recursively flatten a nested object into dotted-key `set` calls |
 | `count(key, amount?)` | Increment a counter (default +1) |
 | `append(key, value)` | Append a value to an array |
 | `max(key, value)` | Track the maximum value for a key |
 | `min(key, value)` | Track the minimum value for a key |
 | `time.start(key)` | Start a timer |
 | `time.stop(key)` | Stop a timer and record elapsed ms |
+| `time.measure(key, fn)` | Time a sync or async callback, returns the callback's result |
 | `errorFields(error, opts?)` | Extract error name, message, and stack |
 | `flush()` | Aggregate all operations and emit the event |
 

package/dist/index.d.ts

@@ -11,9 +11,18 @@ export interface WideloggerOptions {
 export interface ErrorFieldsOptions {
     prefix?: string;
     includeStack?: boolean;
+    slug?: string;
+    retriable?: boolean;
+    requiresReauth?: boolean;
 }
+interface StickyHandle {
+    sticky: () => void;
+}
+declare function measure<K extends string, T>(key: DottedKey<K>, callback: () => Promise<T>): Promise<T>;
+declare function measure<K extends string, T>(key: DottedKey<K>, callback: () => T): T;
 export declare const widelog: {
-    set: <K extends string>(key: DottedKey<K>, value: FieldValue) => void;
+    set: <K extends string>(key: DottedKey<K>, value: FieldValue) => StickyHandle;
+    setFields: (fields: Record<string, unknown>) => StickyHandle;
     count: <K extends string>(key: DottedKey<K>, amount?: number) => void;
     append: <K extends string>(key: DottedKey<K>, value: FieldValue) => void;
     max: <K extends string>(key: DottedKey<K>, value: number) => void;
@@ -21,6 +30,7 @@ export declare const widelog: {
     time: {
         start: <K extends string>(key: DottedKey<K>) => void;
         stop: <K extends string>(key: DottedKey<K>) => void;
+        measure: typeof measure;
     };
     errorFields: (error: unknown, options?: ErrorFieldsOptions) => void;
     flush: () => void;
@@ -33,3 +43,4 @@ export declare const widelogger: (options: WideloggerOptions) => {
     destroy: () => Promise<void>;
 };
 export type Widelog = typeof widelog;
+export {};

package/dist/index.js

@@ -105,7 +105,15 @@ var flush = (context) => {
   if (!context) {
     return {};
   }
+  const hasStickyOperations = context.stickyOperations.length > 0;
+  const hasOperations = context.operations.length > 0;
+  if (!(hasStickyOperations || hasOperations)) {
+    return {};
+  }
   const agg = createAggregators();
+  for (const entry of context.stickyOperations) {
+    processOperation(agg, entry);
+  }
   for (const entry of context.operations) {
     processOperation(agg, entry);
   }
@@ -115,6 +123,9 @@ var flush = (context) => {
 };
 
 // src/index.ts
+var isFieldValue = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isFieldValueArray = (value) => Array.isArray(value) && value.every(isFieldValue);
 function getErrorFields(error, includeStack = true) {
   if (error instanceof Error) {
     return {
@@ -134,38 +145,112 @@ function getErrorFields(error, includeStack = true) {
     error_message: "Unknown error"
   };
 }
+var extractErrorProperty = (error, property) => {
+  if (isRecord2(error) && property in error) {
+    return error[property];
+  }
+  return;
+};
+var noop = () => {
+  return;
+};
+var noopSticky = { sticky: noop };
 var storage = new AsyncLocalStorage;
+function pushOp(operation) {
+  const store = storage.getStore();
+  if (!store) {
+    return noopSticky;
+  }
+  store.operations.push(operation);
+  return {
+    sticky: () => {
+      const index = store.operations.indexOf(operation);
+      if (index !== -1) {
+        store.operations.splice(index, 1);
+      }
+      store.stickyOperations.push(operation);
+    }
+  };
+}
+function applyFields(operations, fields, parentKey) {
+  for (const key of Object.keys(fields)) {
+    const value = fields[key];
+    const fullKey = parentKey ? `${parentKey}.${key}` : key;
+    if (isFieldValue(value)) {
+      operations.push({ operation: "set", key: fullKey, value });
+      continue;
+    }
+    if (isFieldValueArray(value)) {
+      for (const element of value) {
+        operations.push({ operation: "append", key: fullKey, value: element });
+      }
+      continue;
+    }
+    if (isRecord2(value)) {
+      applyFields(operations, value, fullKey);
+    }
+  }
+}
+function measure(key, callback) {
+  const operations = storage.getStore()?.operations;
+  operations?.push({ operation: "time.start", key, time: performance.now() });
+  let result;
+  try {
+    result = callback();
+  } catch (error) {
+    operations?.push({ operation: "time.stop", key, time: performance.now() });
+    throw error;
+  }
+  if (result instanceof Promise) {
+    return result.finally(() => {
+      operations?.push({
+        operation: "time.stop",
+        key,
+        time: performance.now()
+      });
+    });
+  }
+  operations?.push({ operation: "time.stop", key, time: performance.now() });
+  return result;
+}
 var widelog = {
   set: (key, value) => {
-    storage.getStore()?.operations.push({ operation: "set", key, value });
+    return pushOp({ operation: "set", key, value });
+  },
+  setFields: (fields) => {
+    const store = storage.getStore();
+    if (!store) {
+      return noopSticky;
+    }
+    const startIndex = store.operations.length;
+    applyFields(store.operations, fields);
+    return {
+      sticky: () => {
+        const added = store.operations.splice(startIndex);
+        store.stickyOperations.push(...added);
+      }
+    };
   },
   count: (key, amount = 1) => {
-    storage.getStore()?.operations.push({ operation: "count", key, amount });
+    pushOp({ operation: "count", key, amount });
   },
   append: (key, value) => {
-    storage.getStore()?.operations.push({ operation: "append", key, value });
+    pushOp({ operation: "append", key, value });
   },
   max: (key, value) => {
-    storage.getStore()?.operations.push({ operation: "max", key, value });
+    pushOp({ operation: "max", key, value });
   },
   min: (key, value) => {
-    storage.getStore()?.operations.push({ operation: "min", key, value });
+    pushOp({ operation: "min", key, value });
   },
   time: {
     start: (key) => {
-      storage.getStore()?.operations.push({
-        operation: "time.start",
-        key,
-        time: performance.now()
-      });
+      pushOp({ operation: "time.start", key, time: performance.now() });
     },
     stop: (key) => {
-      storage.getStore()?.operations.push({
-        operation: "time.stop",
-        key,
-        time: performance.now()
-      });
-    }
+      pushOp({ operation: "time.stop", key, time: performance.now() });
+    },
+    measure
   },
   errorFields: (error, options = {}) => {
     const context = storage.getStore();
@@ -174,9 +259,15 @@ var widelog = {
     }
     const prefix = options.prefix ?? "error";
     const fields = getErrorFields(error, options.includeStack ?? true);
-    const nameKey = `${prefix}.error_name`;
-    const messageKey = `${prefix}.error_message`;
-    context.operations.push({ operation: "set", key: nameKey, value: fields.error_name }, { operation: "set", key: messageKey, value: fields.error_message });
+    context.operations.push({
+      operation: "set",
+      key: `${prefix}.error_name`,
+      value: fields.error_name
+    }, {
+      operation: "set",
+      key: `${prefix}.error_message`,
+      value: fields.error_message
+    });
     if (fields.error_stack !== undefined) {
       context.operations.push({
         operation: "set",
@@ -184,21 +275,46 @@ var widelog = {
         value: fields.error_stack
       });
     }
+    const slug = options.slug ?? extractErrorProperty(error, "slug");
+    if (typeof slug === "string") {
+      context.operations.push({
+        operation: "set",
+        key: `${prefix}.slug`,
+        value: slug
+      });
+    }
+    const retriable = options.retriable ?? extractErrorProperty(error, "retriable");
+    if (typeof retriable === "boolean") {
+      context.operations.push({
+        operation: "set",
+        key: `${prefix}.retriable`,
+        value: retriable
+      });
+    }
+    const requiresReauth = options.requiresReauth ?? extractErrorProperty(error, "requiresReauth");
+    if (typeof requiresReauth === "boolean") {
+      context.operations.push({
+        operation: "set",
+        key: `${prefix}.requires_reauth`,
+        value: requiresReauth
+      });
+    }
   },
   flush: () => {
     const store = storage.getStore();
     if (!store) {
       return;
     }
-    const event = flush(store);
-    if (Object.keys(event).length === 0) {
+    if (store.operations.length === 0 && store.stickyOperations.length === 0) {
       return;
     }
+    const event = flush(store);
     store.transport(event);
   }
 };
 var widelogger = (options) => {
-  const environment = options.environment ?? "development" ?? "development";
+  const nodeEnvironment = typeof process.env === "object" ? "development" : undefined;
+  const environment = options.environment ?? nodeEnvironment ?? "development";
   const isDevelopment = environment !== "production";
   const pinoTransport = isDevelopment ? pino.transport({
     target: "pino-pretty",
@@ -220,24 +336,26 @@ var widelogger = (options) => {
       environment
     }
   }, pinoTransport);
+  const defaultEventName = options.defaultEventName;
   const transport = (event) => {
     const statusCode = typeof event.status_code === "number" ? event.status_code : undefined;
     const isError = statusCode !== undefined ? statusCode >= 500 : event.outcome === "error";
-    const payload = { event_name: options.defaultEventName, ...event };
+    event.event_name = defaultEventName;
     if (isError) {
-      logger.error(payload);
+      logger.error(event);
       return;
     }
-    logger.info(payload);
+    logger.info(event);
   };
   const clearContext = () => {
     const context2 = storage.getStore();
-    if (context2 && context2.operations.length > 0) {
+    if (context2) {
       context2.operations = [];
+      context2.stickyOperations = [];
     }
   };
   function context(callback) {
-    return storage.run({ operations: [], transport }, () => {
+    return storage.run({ operations: [], stickyOperations: [], transport }, () => {
       let result;
       try {
         result = callback();

package/dist/types.d.ts

@@ -36,6 +36,7 @@ export type Operation = {
 };
 export interface Context {
     operations: Operation[];
+    stickyOperations: Operation[];
     transport: (event: Record<string, unknown>) => void;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "widelogger",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",