unnbound-logger-sdk 3.0.32 → 3.0.35

package/dist/axios.d.ts

@@ -1,11 +1,19 @@
 import { type AxiosInstance, type AxiosRequestConfig, type AxiosResponse } from 'axios';
-import { HttpOptions } from './types';
+import { type HttpOptions } from './types';
 type GetPayload = (config: AxiosRequestConfig, res?: AxiosResponse) => object;
+type RedactOptions = {
+    response?: boolean;
+};
+export type OnRequest = (config: AxiosRequestConfig, callback: (config: AxiosRequestConfig) => Promise<AxiosResponse<any>>) => Promise<AxiosResponse<any>>;
+interface HttpClientOptions extends HttpOptions<GetPayload> {
+    onRequest?: OnRequest;
+    redact?: RedactOptions | boolean;
+}
 /**
  * Wraps an axios instance to add tracing and span tracking
  * @param axios - The axios instance to wrap
  * @param options - Configuration options for HTTP tracing
  * @returns The wrapped axios instance with span tracking
  */
-export declare const traceAxios: (client: AxiosInstance, { ignoreTraceRoutes, traceHeaderKey, getPayload, }?: HttpOptions<GetPayload>) => AxiosInstance;
+export declare const traceAxios: (client: AxiosInstance, { ignoreTraceRoutes, traceHeaderKey, getPayload, onRequest, redact: redactOptions, }?: HttpClientOptions) => AxiosInstance;
 export {};

package/dist/axios.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.traceAxios = void 0;
 const axios_1 = require("axios");
-const types_1 = require("./types");
+const span_1 = require("./span");
 const storage_1 = require("./storage");
+const types_1 = require("./types");
 const utils_1 = require("./utils");
-const span_1 = require("./span");
 const buildUrl = (baseUrl, url) => {
     return url?.startsWith('http') ? url : [baseUrl, url].filter(Boolean).join('');
 };
@@ -16,7 +16,7 @@ const extractQueryParams = (url, config) => {
     keys.forEach((key) => object.searchParams.delete(key));
     return { url: object.toString(), query: keys.length > 0 ? query : undefined };
 };
-const buildOutgoingHttpPayload = (config, res) => ({
+const buildOutgoingHttpPayload = (config, res, redact) => ({
     type: 'http',
     http: {
         ...extractQueryParams(buildUrl(config.baseURL, config.url), config),
@@ -30,23 +30,26 @@ const buildOutgoingHttpPayload = (config, res) => ({
             ? {
                 headers: res?.headers,
                 status: res.status,
-                body: (0, utils_1.safeJsonParse)(res.data),
+                body: redact?.response ? '[Redacted]' : (0, utils_1.safeJsonParse)(res.data),
             }
             : undefined,
     },
 });
 const getNoopPayload = () => ({});
+const onNoopRequest = (config, callback) => callback(config);
 /**
  * Wraps an axios instance to add tracing and span tracking
  * @param axios - The axios instance to wrap
  * @param options - Configuration options for HTTP tracing
  * @returns The wrapped axios instance with span tracking
  */
-const traceAxios = (client, { ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes, traceHeaderKey = types_1.defaultTraceHeaderKey, getPayload = getNoopPayload, } = {
+const traceAxios = (client, { ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes, traceHeaderKey = types_1.defaultTraceHeaderKey, getPayload = getNoopPayload, onRequest = onNoopRequest, redact: redactOptions, } = {
     ignoreTraceRoutes: types_1.defaultIgnoreTraceRoutes,
     traceHeaderKey: types_1.defaultTraceHeaderKey,
     getPayload: getNoopPayload,
+    onRequest: onNoopRequest,
 }) => {
+    const redact = typeof redactOptions === 'boolean' ? { response: redactOptions } : redactOptions;
     const createSpanWrappedRequest = (originalMethod, method) => {
         const { headers: defaultHeaders, ...partialDefaultConfig } = client.defaults;
         const headers = { ...defaultHeaders.common, ...(method && defaultHeaders[method]) };
@@ -59,16 +62,21 @@ const traceAxios = (client, { ignoreTraceRoutes = types_1.defaultIgnoreTraceRout
                 return originalMethod(config);
             const traceId = storage_1.storage.getStore()?.traceId;
             config = { ...config, headers: { ...config.headers, [traceHeaderKey]: traceId } };
-            // Execute the request within a span
-            return (0, span_1.startSpan)(`Outgoing HTTP request`, () => originalMethod(config), (options) => {
-                const response = options
-                    ? options.error
-                        ? (0, axios_1.isAxiosError)(options.error)
-                            ? options.error.response
-                            : undefined
-                        : options.result
-                    : undefined;
-                return { ...buildOutgoingHttpPayload(config, response), ...getPayload(config, response) };
+            return onRequest(config, (config) => {
+                // Execute the request within a span
+                return (0, span_1.startSpan)('Outgoing HTTP request', () => originalMethod(config), (options) => {
+                    const response = options
+                        ? options.error
+                            ? (0, axios_1.isAxiosError)(options.error)
+                                ? options.error.response
+                                : undefined
+                            : options.result
+                        : undefined;
+                    return {
+                        ...buildOutgoingHttpPayload(config, response, redact),
+                        ...getPayload(config, response),
+                    };
+                });
             });
         };
     };

package/dist/emf.d.ts

@@ -0,0 +1,58 @@
+/**
+ * CloudWatch Embedded Metric Format (EMF) support.
+ *
+ * EMF allows you to embed metrics within structured log events.
+ * CloudWatch automatically extracts these as CloudWatch Metrics.
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format.html
+ */
+export type MetricUnit = 'Seconds' | 'Microseconds' | 'Milliseconds' | 'Bytes' | 'Kilobytes' | 'Megabytes' | 'Gigabytes' | 'Terabytes' | 'Bits' | 'Kilobits' | 'Megabits' | 'Gigabits' | 'Terabits' | 'Percent' | 'Count' | 'Bytes/Second' | 'Kilobytes/Second' | 'Megabytes/Second' | 'Gigabytes/Second' | 'Terabytes/Second' | 'Bits/Second' | 'Kilobits/Second' | 'Megabits/Second' | 'Gigabits/Second' | 'Terabits/Second' | 'Count/Second' | 'None';
+export interface MetricDefinition {
+    name: string;
+    unit?: MetricUnit;
+    value: number;
+}
+export interface EmitMetricOptions {
+    /** CloudWatch namespace (default: 'Unnbound') */
+    namespace?: string;
+    /** Dimension names to use for grouping (keys from dimensions object) */
+    dimensionKeys?: string[];
+    /** Additional properties to include in the log */
+    properties?: Record<string, unknown>;
+}
+/**
+ * Emit a metric via CloudWatch EMF format.
+ *
+ * @example
+ * ```ts
+ * // Simple counter
+ * emitMetric(
+ *   { name: 'workflow.created', unit: 'Count', value: 1 },
+ *   { workflowId: 'wf_123', environment: 'prod' }
+ * );
+ *
+ * // Duration histogram
+ * emitMetric(
+ *   { name: 'deployment.duration', unit: 'Seconds', value: 12.5 },
+ *   { workflowId: 'wf_123', status: 'success' },
+ *   { dimensionKeys: ['workflowId', 'status'] }
+ * );
+ * ```
+ */
+export declare function emitMetric(metric: MetricDefinition, dimensions: Record<string, string>, options?: EmitMetricOptions): void;
+/**
+ * Emit multiple metrics in a single EMF log event.
+ * All metrics share the same dimensions.
+ *
+ * @example
+ * ```ts
+ * emitMetrics(
+ *   [
+ *     { name: 'execution.duration', unit: 'Seconds', value: 1.5 },
+ *     { name: 'execution.payload_size', unit: 'Bytes', value: 2048 },
+ *   ],
+ *   { workflowId: 'wf_123', triggerType: 'http' }
+ * );
+ * ```
+ */
+export declare function emitMetrics(metrics: MetricDefinition[], dimensions: Record<string, string>, options?: EmitMetricOptions): void;

package/dist/emf.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitMetric = emitMetric;
+exports.emitMetrics = emitMetrics;
+const logger_1 = require("./logger");
+const DEFAULT_NAMESPACE = 'Unnbound';
+/**
+ * Emit a metric via CloudWatch EMF format.
+ *
+ * @example
+ * ```ts
+ * // Simple counter
+ * emitMetric(
+ *   { name: 'workflow.created', unit: 'Count', value: 1 },
+ *   { workflowId: 'wf_123', environment: 'prod' }
+ * );
+ *
+ * // Duration histogram
+ * emitMetric(
+ *   { name: 'deployment.duration', unit: 'Seconds', value: 12.5 },
+ *   { workflowId: 'wf_123', status: 'success' },
+ *   { dimensionKeys: ['workflowId', 'status'] }
+ * );
+ * ```
+ */
+function emitMetric(metric, dimensions, options = {}) {
+    const { namespace = DEFAULT_NAMESPACE, dimensionKeys, properties = {} } = options;
+    // Use specified dimension keys or all dimension keys
+    const dimKeys = dimensionKeys ?? Object.keys(dimensions);
+    const emfLog = {
+        // EMF metadata
+        _aws: {
+            Timestamp: Date.now(),
+            CloudWatchMetrics: [
+                {
+                    Namespace: namespace,
+                    Dimensions: [dimKeys],
+                    Metrics: [
+                        {
+                            Name: metric.name,
+                            Unit: metric.unit ?? 'None',
+                        },
+                    ],
+                },
+            ],
+        },
+        // Dimension values (must be at root level)
+        ...dimensions,
+        // Metric value (must be at root level with same name)
+        [metric.name]: metric.value,
+        // Additional properties
+        ...properties,
+    };
+    // Log at info level - CloudWatch will extract the metric
+    logger_1.logger.info(emfLog, `metric: ${metric.name}`);
+}
+/**
+ * Emit multiple metrics in a single EMF log event.
+ * All metrics share the same dimensions.
+ *
+ * @example
+ * ```ts
+ * emitMetrics(
+ *   [
+ *     { name: 'execution.duration', unit: 'Seconds', value: 1.5 },
+ *     { name: 'execution.payload_size', unit: 'Bytes', value: 2048 },
+ *   ],
+ *   { workflowId: 'wf_123', triggerType: 'http' }
+ * );
+ * ```
+ */
+function emitMetrics(metrics, dimensions, options = {}) {
+    const { namespace = DEFAULT_NAMESPACE, dimensionKeys, properties = {} } = options;
+    const dimKeys = dimensionKeys ?? Object.keys(dimensions);
+    const metricValues = {};
+    const metricDefinitions = metrics.map((m) => {
+        metricValues[m.name] = m.value;
+        return {
+            Name: m.name,
+            Unit: m.unit ?? 'None',
+        };
+    });
+    const emfLog = {
+        _aws: {
+            Timestamp: Date.now(),
+            CloudWatchMetrics: [
+                {
+                    Namespace: namespace,
+                    Dimensions: [dimKeys],
+                    Metrics: metricDefinitions,
+                },
+            ],
+        },
+        ...dimensions,
+        ...metricValues,
+        ...properties,
+    };
+    const metricNames = metrics.map((m) => m.name).join(', ');
+    logger_1.logger.info(emfLog, `metrics: ${metricNames}`);
+}

package/dist/index.d.ts

@@ -5,10 +5,15 @@
  * 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 { defaultTraceHeaderKey, defaultMessageHeaderKey } from './types';
 export type { ILogger, UnnboundLogger } from './logger';
 export { logger } from './logger';
 export { encode, decode } from './encode';
 export { withTrace, getTraceId } from './trace';
 export { startSpan } from './span';
-export { traceAxios } from './axios';
+export { traceAxios, type OnRequest } from './axios';
 export { traceMiddleware } from './middleware';
+export { storage, withStorage } from './storage';
+export type { UnnboundContext } from './storage';
+export type { MetricUnit, MetricDefinition, EmitMetricOptions } from './emf';
+export { emitMetric, emitMetrics } from './emf';

package/dist/index.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traceMiddleware = exports.traceAxios = exports.startSpan = exports.getTraceId = exports.withTrace = exports.decode = exports.encode = exports.logger = void 0;
+exports.emitMetrics = exports.emitMetric = exports.withStorage = exports.storage = exports.traceMiddleware = exports.traceAxios = exports.startSpan = exports.getTraceId = exports.withTrace = exports.decode = exports.encode = exports.logger = exports.defaultMessageHeaderKey = exports.defaultTraceHeaderKey = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "defaultTraceHeaderKey", { enumerable: true, get: function () { return types_1.defaultTraceHeaderKey; } });
+Object.defineProperty(exports, "defaultMessageHeaderKey", { enumerable: true, get: function () { return types_1.defaultMessageHeaderKey; } });
 var logger_1 = require("./logger");
 Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
 var encode_1 = require("./encode");
@@ -15,3 +18,9 @@ var axios_1 = require("./axios");
 Object.defineProperty(exports, "traceAxios", { enumerable: true, get: function () { return axios_1.traceAxios; } });
 var middleware_1 = require("./middleware");
 Object.defineProperty(exports, "traceMiddleware", { enumerable: true, get: function () { return middleware_1.traceMiddleware; } });
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "storage", { enumerable: true, get: function () { return storage_1.storage; } });
+Object.defineProperty(exports, "withStorage", { enumerable: true, get: function () { return storage_1.withStorage; } });
+var emf_1 = require("./emf");
+Object.defineProperty(exports, "emitMetric", { enumerable: true, get: function () { return emf_1.emitMetric; } });
+Object.defineProperty(exports, "emitMetrics", { enumerable: true, get: function () { return emf_1.emitMetrics; } });

package/dist/internal.d.ts

@@ -1,2 +1,3 @@
 export declare const hidden: (data: object) => unknown;
+/** @public - used by SDK consumers via dist/internal */
 export declare const internal: () => Record<string, unknown>;

package/dist/internal.js

@@ -8,5 +8,6 @@ if (process.env.UNNBOUND_IDLE_TIMEOUT)
     o._hide = true;
 const hidden = (data) => '_hide' in data && data._hide;
 exports.hidden = hidden;
+/** @public - used by SDK consumers via dist/internal */
 const internal = () => o;
 exports.internal = internal;

package/dist/logger.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 const pino_1 = __importDefault(require("pino"));
 const uuid_1 = require("uuid");
-const storage_1 = require("./storage");
 const encode_1 = require("./encode");
 const internal_1 = require("./internal");
+const storage_1 = require("./storage");
 const levels = new Set(['debug', 'info', 'warn', 'error']);
 const formatLevel = (level) => ({ level });
 // TODO: Check if there is a better way to encode the log object.
@@ -24,7 +24,7 @@ const formatLog = (log, visited = new WeakSet()) => {
     for (const key in log) {
         const value = log[key];
         // We don't want to encode undefined values.
-        if (value == undefined)
+        if (value === undefined)
             continue;
         // We can't encode immutable properties.
         if (!Object.getOwnPropertyDescriptor(log, key)?.writable)
@@ -52,6 +52,7 @@ exports.logger = (0, pino_1.default)({
         workflowId: process.env.UNNBOUND_WORKFLOW_ID,
         serviceId: process.env.UNNBOUND_SERVICE_ID,
         deploymentId: process.env.UNNBOUND_DEPLOYMENT_ID,
+        source: process.env.UNNBOUND_LOG_SOURCE ?? 'workflow',
     },
     mixin: () => ({ ...storage_1.storage.getStore(), logId: (0, uuid_1.v4)() }),
     serializers: {
@@ -73,9 +74,7 @@ exports.logger = (0, pino_1.default)({
                 if ((0, internal_1.hidden)(firstArg))
                     return;
                 // Dynamic log level by allowing overwriting the log level
-                if ('level' in firstArg &&
-                    typeof firstArg.level === 'string' &&
-                    levels.has(firstArg.level)) {
+                if ('level' in firstArg && typeof firstArg.level === 'string' && levels.has(firstArg.level)) {
                     method = this[firstArg.level];
                     firstArg.level = undefined;
                 }
@@ -96,7 +95,7 @@ exports.logger = (0, pino_1.default)({
 });
 process.on('uncaughtException', (err, origin) => {
     try {
-        exports.logger.error({ err, origin }, `Uncaught exception.`);
+        exports.logger.error({ err, origin }, 'Uncaught exception.');
     }
     catch {
         // noop
@@ -104,7 +103,7 @@ process.on('uncaughtException', (err, origin) => {
 });
 process.on('unhandledRejection', (err, origin) => {
     try {
-        exports.logger.error({ err, origin }, `Unhandled rejection.`);
+        exports.logger.error({ err, origin }, 'Unhandled rejection.');
     }
     catch {
         // noop

package/dist/middleware.d.ts

@@ -1,5 +1,5 @@
-import { Request, RequestHandler } from 'express';
-import { HttpOptions } from './types';
+import type { Request, RequestHandler } from 'express';
+import { type HttpOptions } from './types';
 interface Response {
     status: number;
     headers?: Record<string, string | undefined>;

package/dist/middleware.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.traceMiddleware = void 0;
 const span_1 = require("./span");
 const types_1 = require("./types");
-const utils_1 = require("./utils");
 const trace_1 = require("./trace");
+const utils_1 = require("./utils");
 const extractQueryParams = (url) => {
     const object = new URL(url);
     const query = Object.fromEntries(object.searchParams.entries());
@@ -18,8 +18,9 @@ const getFullUrl = (req) => {
         return url;
     // Check if we have a workflow URL configured (preferred method)
     if (process.env.UNNBOUND_WORKFLOW_URL) {
-        // Use workflow URL as the base URL
-        return `https://${process.env.UNNBOUND_WORKFLOW_URL.replace(/\/$/, '')}${url}`;
+        // Use workflow URL as the base URL (strip any existing protocol to avoid duplication)
+        const workflowUrl = process.env.UNNBOUND_WORKFLOW_URL.replace(/^https?:\/\//, '').replace(/\/$/, '');
+        return `https://${workflowUrl}${url}`;
     }
     // Fallback to constructing from request info for incoming requests
     const protocol = req.protocol || (req.secure ? 'https' : 'http');

package/dist/span.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from './types';
+import type { Maybe } from './types';
 export type LogPayloadGetterOptions<T> = Maybe<T>;
 type LogPayloadGetter<T> = object | ((o?: LogPayloadGetterOptions<T>) => object);
 /**

package/dist/span.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startSpan = void 0;
 const uuid_1 = require("uuid");
+const logger_1 = require("./logger");
 const storage_1 = require("./storage");
 const trace_1 = require("./trace");
-const logger_1 = require("./logger");
 /**
  * Starts a span that tracks the duration of a callback
  * @param spanName - The span name to use for logging

package/dist/storage.d.ts

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from 'async_hooks';
+import { AsyncLocalStorage } from 'node:async_hooks';
 export interface UnnboundContext {
     traceId?: string;
     spanId?: string;

package/dist/storage.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withStorage = exports.storage = void 0;
-const async_hooks_1 = require("async_hooks");
-exports.storage = new async_hooks_1.AsyncLocalStorage();
+const node_async_hooks_1 = require("node:async_hooks");
+exports.storage = new node_async_hooks_1.AsyncLocalStorage();
 const withStorage = async (data, callback) => {
     const previous = exports.storage.getStore();
     return exports.storage.run({ ...previous, ...data }, callback);

package/dist/trace.d.ts

@@ -5,6 +5,7 @@
 export declare const getTraceId: () => string;
 /**
  * Generates a message ID
+ * @public - used by SDK consumers via dist/trace
  * @returns A message ID
  */
 export declare const getMessageId: () => string;

package/dist/trace.js

@@ -11,6 +11,7 @@ const getTraceId = () => (0, uuid_1.v4)();
 exports.getTraceId = getTraceId;
 /**
  * Generates a message ID
+ * @public - used by SDK consumers via dist/trace
  * @returns A message ID
  */
 const getMessageId = () => (0, uuid_1.v4)();

package/package.json

@@ -1,21 +1,19 @@
 {
   "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.32",
+  "version": "3.0.35",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
-    "test": "jest",
-    "test:coverage": "jest --coverage",
-    "test:watch": "jest --watch",
+    "build": "bun x tsc",
+    "test": "echo 'No tests'",
     "typecheck": "tsc -noEmit",
     "lint": "eslint --cache --cache-location ./node_modules/.cache/eslint .",
-    "lint:fix": "pnpm lint --fix",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "prepublishOnly": "pnpm build",
-    "start:example": "npx --yes tsx --watch examples/node-express.ts",
+    "lint:fix": "bun run lint --fix",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
+    "prepublishOnly": "bun run build",
+    "start:example": "bun --watch examples/node-express.ts",
     "version:bump": "npm version patch"
   },
   "keywords": [
@@ -47,9 +45,9 @@
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
-    "@types/jest": "^29.5.12",
     "@types/node": "^22",
-    "@types/uuid": "^9.0.8"
+    "@types/uuid": "^9.0.8",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "axios": "^1.12.2",