sloplog 0.0.4 → 0.0.6

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({
+        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

@@ -17,25 +17,45 @@ export interface SentryLogger {
  */
 export interface SentryCollectorOptions {
     /**
-     * Sentry logger instance (e.g. Sentry.logger). Requires the Sentry logger
-     * integration to be configured during Sentry.init().
+     * Sentry logger instance (e.g. Sentry.logger) or a function that returns it.
+     * Using a getter function allows lazy initialization (e.g., waiting for Sentry.init()).
+     * Requires the Sentry logger integration to be configured during Sentry.init().
      */
-    logger: SentryLogger;
+    logger: SentryLogger | (() => SentryLogger | undefined);
     /** Default log level for events (default: "info") */
     level?: SentryLogLevel;
     /** Optional function to derive log level per event */
     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 getLogger;
     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,69 @@
+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;
+    getLogger;
     defaultLevel;
     levelSelector;
     message;
+    flattenAttributes;
+    suppressConsole;
     constructor(options) {
-        this.logger = options.logger;
+        // Support both direct logger and getter function for lazy initialization
+        this.getLogger =
+            typeof options.logger === 'function' ? options.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 logger = this.getLogger();
+        if (!logger) {
+            return;
+        }
         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' && logger.trace) ||
+                (level === 'debug' && logger.debug) ||
+                (level === 'info' && logger.info) ||
+                (level === 'warn' && logger.warn) ||
+                (level === 'error' && logger.error) ||
+                (level === 'fatal' && logger.fatal);
+            if (loggerMethod) {
+                loggerMethod(this.message, attributes);
+                return;
+            }
+            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/dist/index.d.ts

@@ -1,8 +1,10 @@
 import type { ZodRawShape } from 'zod';
 import type { LogCollectorClient } from './collectors/index.js';
+export * from './collectors/index.js';
+export * from './collectors/sentry.js';
 import type { PartialMetadata, PartialDefinition, PartialOptions, Registry, RegistryType } from './registry.js';
 /** Current sloplog library version (propagated onto Service). */
-export declare const SLOPLOG_VERSION = "0.0.2";
+export declare const SLOPLOG_VERSION = "0.0.6";
 /**
  * TYPES
  */

package/dist/index.js

@@ -1,4 +1,7 @@
 import { extractPartialMetadata } from './registry.js';
+// Re-export collectors from main entry point for easier bundler compatibility
+export * from './collectors/index.js';
+export * from './collectors/sentry.js';
 /**
  * Generate a nano ID for unique identifiers
  */
@@ -11,7 +14,7 @@ function nanoId() {
     return result;
 }
 /** Current sloplog library version (propagated onto Service). */
-export const SLOPLOG_VERSION = '0.0.2';
+export const SLOPLOG_VERSION = '0.0.6';
 /** Default language marker when Service.sloplogLanguage is not set. */
 const SLOPLOG_LANGUAGE = 'typescript';
 function isOriginatorResult(input) {

package/dist/partials.d.ts

@@ -11,11 +11,11 @@ declare const error: import("./registry.js").PartialFactory<"error", {
 declare const logMessage: import("./registry.js").PartialFactory<"log_message", {
     message: z.ZodString;
     level: z.ZodEnum<{
-        error: "error";
         trace: "trace";
         debug: "debug";
         info: "info";
         warn: "warn";
+        error: "error";
         fatal: "fatal";
     }>;
     data: z.ZodOptional<z.ZodString>;
@@ -57,11 +57,11 @@ export declare const builtInPartials: {
     log_message: import("./registry.js").PartialFactory<"log_message", {
         message: z.ZodString;
         level: z.ZodEnum<{
-            error: "error";
             trace: "trace";
             debug: "debug";
             info: "info";
             warn: "warn";
+            error: "error";
             fatal: "fatal";
         }>;
         data: z.ZodOptional<z.ZodString>;
@@ -102,11 +102,11 @@ export declare const builtInRegistry: import("./registry.js").Registry<(import("
 }> | import("./registry.js").PartialFactory<"log_message", {
     message: z.ZodString;
     level: z.ZodEnum<{
-        error: "error";
         trace: "trace";
         debug: "debug";
         info: "info";
         warn: "warn";
+        error: "error";
         fatal: "fatal";
     }>;
     data: z.ZodOptional<z.ZodString>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sloplog",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "A TypeScript library for constructing wide events",
   "type": "module",
   "main": "dist/index.js",