sloplog 0.0.3 → 0.0.5

package/dist/collectors/index.d.ts

@@ -1,4 +1,20 @@
 import type { WideEventBase, EventPartial } from '../index.js';
+/**
+ * Truncate a stack trace to MAX_STACK_LINES lines
+ */
+export declare function truncateStack(stack: string | undefined): string | undefined;
+/**
+ * Flatten a nested object to dot-notation keys.
+ * Arrays use numeric indices: `partialName.0.subKey`
+ * Stack traces are automatically truncated.
+ */
+export declare function flattenObject(obj: unknown, prefix?: string, result?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Execute a function with all console methods suppressed.
+ * Useful for preventing Sentry SDK from outputting its own logs to console
+ * when we're already handling console output ourselves.
+ */
+export declare function withSuppressedConsole<T>(fn: () => T): T;
 /**
  * Options passed to collectors when flushing an event
  */
@@ -19,16 +35,34 @@ export interface LogCollectorClient {
 }
 /** Type alias for partial values (singular or array) */
 type PartialValue = EventPartial<string> | EventPartial<string>[];
+/**
+ * Options for StdioCollector
+ */
+export interface StdioCollectorOptions {
+    /**
+     * Prefix to prepend to each log line.
+     * Default: "[wide-event]"
+     */
+    prefix?: string;
+    /**
+     * If true, pretty-print the JSON output with 2-space indentation.
+     * Default: true
+     */
+    prettyPrint?: boolean;
+}
 /**
  * Simple collector to log the event to stdout/console
  */
 export declare class StdioCollector implements LogCollectorClient {
+    private prefix;
+    private prettyPrint;
+    constructor(options?: StdioCollectorOptions);
     flush(eventBase: WideEventBase, partials: Map<string, PartialValue>, _options: FlushOptions): Promise<void>;
 }
 /**
  * Create a collector that logs events to stdout/console.
  */
-export declare function stdioCollector(): StdioCollector;
+export declare function stdioCollector(options?: StdioCollectorOptions): StdioCollector;
 /**
  * Composes multiple collectors together, flushing to all of them in parallel
  */

package/dist/collectors/index.js

@@ -1,24 +1,116 @@
+/**
+ * Maximum number of stack trace lines to include in error logs
+ */
+const MAX_STACK_LINES = 10;
+/**
+ * Truncate a stack trace to MAX_STACK_LINES lines
+ */
+export function truncateStack(stack) {
+    if (!stack)
+        return stack;
+    const lines = stack.split('\n');
+    if (lines.length <= MAX_STACK_LINES)
+        return stack;
+    return lines.slice(0, MAX_STACK_LINES).join('\n') + '\n    ... truncated';
+}
+/**
+ * Flatten a nested object to dot-notation keys.
+ * Arrays use numeric indices: `partialName.0.subKey`
+ * Stack traces are automatically truncated.
+ */
+export function flattenObject(obj, prefix = '', result = {}) {
+    if (obj === null || obj === undefined) {
+        if (prefix) {
+            result[prefix] = obj;
+        }
+        return result;
+    }
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            flattenObject(obj[i], prefix ? `${prefix}.${i}` : String(i), result);
+        }
+        return result;
+    }
+    if (typeof obj === 'object') {
+        for (const [key, value] of Object.entries(obj)) {
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            // Truncate stack traces
+            if (key === 'stack' && typeof value === 'string') {
+                result[newKey] = truncateStack(value);
+            }
+            else {
+                flattenObject(value, newKey, result);
+            }
+        }
+        return result;
+    }
+    if (prefix) {
+        result[prefix] = obj;
+    }
+    return result;
+}
+/**
+ * Execute a function with all console methods suppressed.
+ * Useful for preventing Sentry SDK from outputting its own logs to console
+ * when we're already handling console output ourselves.
+ */
+export function withSuppressedConsole(fn) {
+    /* eslint-disable no-console */
+    const noop = () => { };
+    const originalLog = console.log;
+    const originalInfo = console.info;
+    const originalWarn = console.warn;
+    const originalError = console.error;
+    const originalDebug = console.debug;
+    const originalTrace = console.trace;
+    console.log = noop;
+    console.info = noop;
+    console.warn = noop;
+    console.error = noop;
+    console.debug = noop;
+    console.trace = noop;
+    try {
+        return fn();
+    }
+    finally {
+        console.log = originalLog;
+        console.info = originalInfo;
+        console.warn = originalWarn;
+        console.error = originalError;
+        console.debug = originalDebug;
+        console.trace = originalTrace;
+    }
+    /* eslint-enable no-console */
+}
 /**
  * Simple collector to log the event to stdout/console
  */
 export class StdioCollector {
+    prefix;
+    prettyPrint;
+    constructor(options = {}) {
+        this.prefix = options.prefix ?? '[wide-event]';
+        this.prettyPrint = options.prettyPrint ?? true;
+    }
     async flush(eventBase, partials, _options) {
         const partialsObj = {};
         for (const [key, value] of partials) {
             partialsObj[key] = value;
         }
-        // eslint-disable-next-line no-console
-        console.log(JSON.stringify({
+        const event = {
             ...eventBase,
             ...partialsObj,
-        }));
+        };
+        const json = this.prettyPrint ? JSON.stringify(event, null, 2) : JSON.stringify(event);
+        // eslint-disable-next-line no-console
+        console.log(this.prefix, json);
     }
 }
 /**
  * Create a collector that logs events to stdout/console.
  */
-export function stdioCollector() {
-    return new StdioCollector();
+export function stdioCollector(options = {}) {
+    return new StdioCollector(options);
 }
 /**
  * Composes multiple collectors together, flushing to all of them in parallel

package/dist/collectors/sentry.d.ts

@@ -27,15 +27,34 @@ export interface SentryCollectorOptions {
     levelSelector?: (event: WideEventBase, partials: Map<string, PartialValue>, options: FlushOptions) => SentryLogLevel;
     /** Log message to use (default: "wide-event") */
     message?: string;
+    /**
+     * If true, flatten nested attributes to dot-notation keys for better
+     * queryability in Sentry (e.g., `error.message`, `spans.0.name`).
+     * Default: true
+     */
+    flattenAttributes?: boolean;
+    /**
+     * If true, suppress console output from Sentry SDK during logging.
+     * Useful when you're already handling console output via another collector.
+     * Default: true
+     */
+    suppressConsole?: boolean;
 }
 /**
- * Collector that sends events to Sentry Logs via the Sentry logger API
+ * Collector that sends events to Sentry Logs via the Sentry logger API.
+ *
+ * Note: This is a hacky implementation that doesn't fully take advantage
+ * of Sentry's features. It flattens nested objects to dot-notation keys
+ * for queryability, but Sentry's structured logging would be more powerful
+ * if used with proper Sentry integrations.
  */
 export declare class SentryCollector implements LogCollectorClient {
     private logger;
     private defaultLevel;
     private levelSelector?;
     private message;
+    private flattenAttributes;
+    private suppressConsole;
     constructor(options: SentryCollectorOptions);
     flush(event: WideEventBase, partials: Map<string, PartialValue>, options: FlushOptions): Promise<void>;
 }

package/dist/collectors/sentry.js

@@ -1,40 +1,63 @@
+import { flattenObject, withSuppressedConsole } from './index.js';
 /**
- * Collector that sends events to Sentry Logs via the Sentry logger API
+ * Collector that sends events to Sentry Logs via the Sentry logger API.
+ *
+ * Note: This is a hacky implementation that doesn't fully take advantage
+ * of Sentry's features. It flattens nested objects to dot-notation keys
+ * for queryability, but Sentry's structured logging would be more powerful
+ * if used with proper Sentry integrations.
  */
 export class SentryCollector {
     logger;
     defaultLevel;
     levelSelector;
     message;
+    flattenAttributes;
+    suppressConsole;
     constructor(options) {
         this.logger = options.logger;
         this.defaultLevel = options.level ?? 'info';
         this.levelSelector = options.levelSelector;
         this.message = options.message ?? 'wide-event';
+        this.flattenAttributes = options.flattenAttributes ?? true;
+        this.suppressConsole = options.suppressConsole ?? true;
     }
     async flush(event, partials, options) {
         const partialsObj = {};
         for (const [key, value] of partials) {
             partialsObj[key] = value;
         }
-        const attributes = {
+        const combined = {
             ...event,
             ...partialsObj,
         };
+        // Flatten nested attributes to dot-notation for better Sentry queryability
+        const attributes = this.flattenAttributes
+            ? flattenObject(combined)
+            : combined;
         const level = this.levelSelector
             ? this.levelSelector(event, partials, options)
             : this.defaultLevel;
-        const loggerMethod = (level === 'trace' && this.logger.trace) ||
-            (level === 'debug' && this.logger.debug) ||
-            (level === 'info' && this.logger.info) ||
-            (level === 'warn' && this.logger.warn) ||
-            (level === 'error' && this.logger.error) ||
-            (level === 'fatal' && this.logger.fatal);
-        if (loggerMethod) {
-            loggerMethod(this.message, attributes);
-            return;
+        const logFn = () => {
+            const loggerMethod = (level === 'trace' && this.logger.trace) ||
+                (level === 'debug' && this.logger.debug) ||
+                (level === 'info' && this.logger.info) ||
+                (level === 'warn' && this.logger.warn) ||
+                (level === 'error' && this.logger.error) ||
+                (level === 'fatal' && this.logger.fatal);
+            if (loggerMethod) {
+                loggerMethod(this.message, attributes);
+                return;
+            }
+            this.logger.log?.(level, this.message, attributes);
+        };
+        // Suppress console output from Sentry SDK if configured
+        if (this.suppressConsole) {
+            withSuppressedConsole(logFn);
+        }
+        else {
+            logFn();
         }
-        this.logger.log?.(level, this.message, attributes);
     }
 }
 /**

package/package.json

@@ -1,46 +1,55 @@
 {
   "name": "sloplog",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "A TypeScript library for constructing wide events",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "default": "./dist/index.js"
     },
     "./codegen": {
+      "types": "./dist/codegen.d.ts",
       "import": "./dist/codegen.js",
-      "types": "./dist/codegen.d.ts"
+      "default": "./dist/codegen.js"
     },
     "./partials": {
+      "types": "./dist/partials.d.ts",
       "import": "./dist/partials.js",
-      "types": "./dist/partials.d.ts"
+      "default": "./dist/partials.js"
     },
     "./collectors/stdio": {
+      "types": "./dist/collectors/stdio.d.ts",
       "import": "./dist/collectors/stdio.js",
-      "types": "./dist/collectors/stdio.d.ts"
+      "default": "./dist/collectors/stdio.js"
     },
     "./collectors/composite": {
+      "types": "./dist/collectors/composite.d.ts",
       "import": "./dist/collectors/composite.js",
-      "types": "./dist/collectors/composite.d.ts"
+      "default": "./dist/collectors/composite.js"
     },
     "./collectors/filtered": {
+      "types": "./dist/collectors/filtered.d.ts",
       "import": "./dist/collectors/filtered.js",
-      "types": "./dist/collectors/filtered.d.ts"
+      "default": "./dist/collectors/filtered.js"
     },
     "./collectors/file": {
+      "types": "./dist/collectors/file.d.ts",
       "import": "./dist/collectors/file.js",
-      "types": "./dist/collectors/file.d.ts"
+      "default": "./dist/collectors/file.js"
     },
     "./collectors/betterstack": {
+      "types": "./dist/collectors/betterstack.d.ts",
       "import": "./dist/collectors/betterstack.js",
-      "types": "./dist/collectors/betterstack.d.ts"
+      "default": "./dist/collectors/betterstack.js"
     },
     "./collectors/sentry": {
+      "types": "./dist/collectors/sentry.d.ts",
       "import": "./dist/collectors/sentry.js",
-      "types": "./dist/collectors/sentry.d.ts"
+      "default": "./dist/collectors/sentry.js"
     }
   },
   "files": [