widelogger 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { DottedKey, FieldValue } from "./types";
+import type { DottedKey, ErrorParser, FieldValue } from "./types";
 export interface WideloggerOptions {
     service: string;
     defaultEventName: string;
@@ -11,12 +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;
-    setFields: (fields: Record<string, unknown>) => 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;
@@ -26,6 +32,8 @@ export declare const widelog: {
         stop: <K extends string>(key: DottedKey<K>) => void;
         measure: typeof measure;
     };
+    errors: (parser: ErrorParser) => void;
+    error: <K extends string>(key: DottedKey<K>, error: unknown) => void;
     errorFields: (error: unknown, options?: ErrorFieldsOptions) => void;
     flush: () => void;
 };

package/dist/index.js

@@ -32,9 +32,29 @@ var createAggregators = () => ({
   arrays: Object.create(null),
   maxValues: Object.create(null),
   minValues: Object.create(null),
-  timers: Object.create(null)
+  timers: Object.create(null),
+  errors: Object.create(null)
 });
-var processOperation = (agg, entry) => {
+var aggregateError = (agg, key, slug) => {
+  const existing = agg.errors[key];
+  if (existing) {
+    existing.total += 1;
+    const previousCount = existing.counts[slug];
+    if (typeof previousCount === "number") {
+      existing.counts[slug] = previousCount + 1;
+    } else {
+      existing.counts[slug] = 1;
+      existing.slugs.push(slug);
+    }
+  } else {
+    agg.errors[key] = {
+      slugs: [slug],
+      counts: { [slug]: 1 },
+      total: 1
+    };
+  }
+};
+var processOperation = (agg, entry, errorParser) => {
   switch (entry.operation) {
     case "set":
       setNested(agg.event, entry.key, entry.value);
@@ -66,9 +86,9 @@ var processOperation = (agg, entry) => {
       break;
     }
     case "time.start": {
-      const existing = agg.timers[entry.key];
-      if (existing) {
-        existing.start = entry.time;
+      const existingTimer = agg.timers[entry.key];
+      if (existingTimer) {
+        existingTimer.start = entry.time;
       } else {
         agg.timers[entry.key] = { start: entry.time, accumulated: 0 };
       }
@@ -82,6 +102,13 @@ var processOperation = (agg, entry) => {
       }
       break;
     }
+    case "error": {
+      if (errorParser) {
+        const slug = errorParser(entry.error);
+        aggregateError(agg, entry.key, slug);
+      }
+      break;
+    }
     default:
   }
 };
@@ -90,7 +117,8 @@ var mergeAggregators = (agg) => {
     agg.counters,
     agg.arrays,
     agg.maxValues,
-    agg.minValues
+    agg.minValues,
+    agg.errors
   ];
   for (const source of sources) {
     for (const key of Object.keys(source)) {
@@ -105,9 +133,17 @@ 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, context.errorParser);
+  }
   for (const entry of context.operations) {
-    processOperation(agg, entry);
+    processOperation(agg, entry, context.errorParser);
   }
   mergeAggregators(agg);
   context.operations = [];
@@ -117,6 +153,7 @@ 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 {
@@ -136,9 +173,32 @@ 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) {
-  storage.getStore()?.operations.push(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)) {
@@ -148,6 +208,12 @@ function applyFields(operations, fields, parentKey) {
       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);
     }
@@ -177,13 +243,21 @@ function measure(key, callback) {
 }
 var widelog = {
   set: (key, value) => {
-    pushOp({ operation: "set", key, value });
+    return pushOp({ operation: "set", key, value });
   },
   setFields: (fields) => {
-    const operations = storage.getStore()?.operations;
-    if (operations) {
-      applyFields(operations, 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) => {
     pushOp({ operation: "count", key, amount });
@@ -206,6 +280,16 @@ var widelog = {
     },
     measure
   },
+  errors: (parser) => {
+    const store = storage.getStore();
+    if (!store) {
+      return;
+    }
+    store.errorParser = parser;
+  },
+  error: (key, error) => {
+    pushOp({ operation: "error", key, error });
+  },
   errorFields: (error, options = {}) => {
     const context = storage.getStore();
     if (!context) {
@@ -229,10 +313,37 @@ 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 || store.operations.length === 0) {
+    if (!store) {
+      return;
+    }
+    if (store.operations.length === 0 && store.stickyOperations.length === 0) {
       return;
     }
     const event = flush(store);
@@ -276,12 +387,18 @@ var widelogger = (options) => {
   };
   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: [],
+      errorParser: null,
+      transport
+    }, () => {
       let result;
       try {
         result = callback();

package/dist/types.d.ts

@@ -5,6 +5,7 @@ interface KeyErrorBrand {
 }
 type ValidateKey<T extends string> = T extends "" ? "widelog keys cannot be empty" & KeyErrorBrand : T extends `.${string}` ? "widelog keys cannot start with a dot" & KeyErrorBrand : T extends `${string}.` ? "widelog keys cannot end with a dot" & KeyErrorBrand : T extends `${string}..${string}` ? "widelog keys cannot contain empty segments" & KeyErrorBrand : T;
 export type DottedKey<T extends string> = ValidateKey<T>;
+export type ErrorParser = (error: unknown) => string;
 export type Operation = {
     operation: "set";
     key: string;
@@ -33,9 +34,15 @@ export type Operation = {
     operation: "time.stop";
     key: string;
     time: number;
+} | {
+    operation: "error";
+    key: string;
+    error: unknown;
 };
 export interface Context {
     operations: Operation[];
+    stickyOperations: Operation[];
+    errorParser: ErrorParser | null;
     transport: (event: Record<string, unknown>) => void;
 }
 export {};

package/package.json

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