widelogger 0.3.0 → 0.4.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

@@ -12,8 +12,11 @@ export interface ErrorFieldsOptions {
     prefix?: string;
     includeStack?: boolean;
 }
+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;
+    setFields: (fields: Record<string, unknown>) => void;
     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 +24,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 +37,4 @@ export declare const widelogger: (options: WideloggerOptions) => {
     destroy: () => Promise<void>;
 };
 export type Widelog = typeof widelog;
+export {};

package/dist/index.js

@@ -115,6 +115,8 @@ 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);
 function getErrorFields(error, includeStack = true) {
   if (error instanceof Error) {
     return {
@@ -135,37 +137,74 @@ function getErrorFields(error, includeStack = true) {
   };
 }
 var storage = new AsyncLocalStorage;
+function pushOp(operation) {
+  storage.getStore()?.operations.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 (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 });
+    pushOp({ operation: "set", key, value });
+  },
+  setFields: (fields) => {
+    const operations = storage.getStore()?.operations;
+    if (operations) {
+      applyFields(operations, fields);
+    }
   },
   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 +213,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",
@@ -187,18 +232,16 @@ var widelog = {
   },
   flush: () => {
     const store = storage.getStore();
-    if (!store) {
+    if (!store || store.operations.length === 0) {
       return;
     }
     const event = flush(store);
-    if (Object.keys(event).length === 0) {
-      return;
-    }
     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,15 +263,16 @@ 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();

package/package.json

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