unnbound-logger-sdk 3.0.24 → 3.0.25

package/dist/axios.js

@@ -6,6 +6,9 @@ const types_1 = require("./types");
 const storage_1 = require("./storage");
 const utils_1 = require("./utils");
 const span_1 = require("./span");
+const buildUrl = (baseUrl, url) => {
+    return url?.startsWith('http') ? url : [baseUrl, url].filter(Boolean).join('');
+};
 const extractQueryParams = (url, config) => {
     const object = new URL(url);
     const query = { ...Object.fromEntries(object.searchParams.entries()), ...config.params };
@@ -16,7 +19,7 @@ const extractQueryParams = (url, config) => {
 const buildOutgoingHttpPayload = (config, res) => ({
     type: 'http',
     http: {
-        ...extractQueryParams([config.baseURL, config.url].filter(Boolean).join(''), config),
+        ...extractQueryParams(buildUrl(config.baseURL, config.url), config),
         method: config.method?.toLowerCase() ?? 'get',
         incoming: false,
         request: {
@@ -50,8 +53,7 @@ const traceAxios = (client, { ignoreTraceRoutes = types_1.defaultIgnoreTraceRout
         const defaultConfig = { ...partialDefaultConfig, headers };
         return async (config) => {
             config = (0, axios_1.mergeConfig)(defaultConfig, config);
-            // Determine the actual config and URL
-            const url = [config.baseURL, config.url].filter(Boolean).join('');
+            const url = buildUrl(config.baseURL, config.url);
             // Check if this request should be ignored
             if ((0, utils_1.shouldIgnorePath)(url, ignoreTraceRoutes))
                 return originalMethod(config);

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  * Provides consistent, well-typed logging across different operational contexts.
  */
 export type { LogLevel, LogType, HttpMethod, Maybe, EventSource, Log, HttpPayload, SftpPayload, EdiPayload, EdiOperation, EdiFormat, EdiX12Payload, EdiX12Operation, } from './types';
-export type { UnnboundLogger } from './logger';
+export type { ILogger, UnnboundLogger } from './logger';
 export { logger } from './logger';
 export { encode, decode } from './encode';
 export { withTrace, getTraceId } from './trace';

package/dist/logger.d.ts

@@ -1,5 +1,5 @@
 import pino from 'pino';
-export interface UnnboundLogger extends Omit<pino.Logger, 'trace' | 'debug' | 'error' | 'info' | 'warn'> {
+export interface ILogger {
     trace(object: {}, message: string): void;
     trace(message: string): void;
     debug(object: {}, message: string): void;
@@ -12,4 +12,6 @@ export interface UnnboundLogger extends Omit<pino.Logger, 'trace' | 'debug' | 'e
         err: unknown;
     }>(object: O, message: string): void;
 }
+export interface UnnboundLogger extends ILogger, Omit<pino.Logger, keyof ILogger> {
+}
 export declare const logger: UnnboundLogger;

package/dist/logger.js

@@ -11,17 +11,38 @@ const encode_1 = require("./encode");
 const internal_1 = require("./internal");
 const levels = new Set(['debug', 'info', 'warn', 'error']);
 const formatLevel = (level) => ({ level });
-const formatLog = (log) => {
-    Object.entries(log).forEach(([key, value]) => {
-        if (value && typeof value === 'object') {
-            log[key] = formatLog(value);
-            return;
-        }
+// TODO: Check if there is a better way to encode the log object.
+const formatLog = (log, visited = new WeakSet()) => {
+    // Prevent infinite loops from circular references
+    if (visited.has(log))
+        return log;
+    visited.add(log);
+    // We can't encode frozen objects.
+    if (Object.isFrozen(log))
+        return log;
+    // We don't use Object.entries() for performance reasons
+    for (const key in log) {
+        const value = log[key];
+        // We don't want to encode undefined values.
+        if (value == undefined)
+            continue;
+        // We can't encode immutable properties.
+        if (!Object.getOwnPropertyDescriptor(log, key)?.writable)
+            continue;
         if (typeof value === 'string') {
             log[key] = (0, encode_1.encode)(value);
-            return;
         }
-    });
+        else if (Array.isArray(value)) {
+            log[key] = value.map((item) => typeof item === 'string'
+                ? (0, encode_1.encode)(item)
+                : item && typeof item === 'object'
+                    ? formatLog(item, visited)
+                    : item);
+        }
+        else if (typeof value === 'object') {
+            log[key] = formatLog(value, visited);
+        }
+    }
     return log;
 };
 exports.logger = (0, pino_1.default)({
@@ -74,5 +95,18 @@ exports.logger = (0, pino_1.default)({
     },
 });
 process.on('uncaughtException', (err, origin) => {
-    exports.logger.error({ err, origin }, `Uncaught exception.`);
+    try {
+        exports.logger.error({ err, origin }, `Uncaught exception.`);
+    }
+    catch {
+        // noop
+    }
+});
+process.on('unhandledRejection', (err, origin) => {
+    try {
+        exports.logger.error({ err, origin }, `Unhandled rejection.`);
+    }
+    catch {
+        // noop
+    }
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unnbound-logger-sdk",
   "description": "A structured logging library with TypeScript support using Pino. Provides consistent, well-typed logging with automatic logId, workflowId, traceId, and deploymentId tracking across operational contexts.",
-  "version": "3.0.24",
+  "version": "3.0.25",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [