widelogger 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -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;

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);
   }
@@ -117,6 +125,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 +145,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 +180,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 +215,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 });
@@ -229,10 +275,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 +349,13 @@ 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: [], 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.4.0",
+  "version": "0.5.0",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",