unnbound-logger-sdk 2.0.10 → 3.0.1

package/README.md

@@ -1,6 +1,6 @@
 # Unnbound Logger
 
-A structured logging library with TypeScript support built on Pino. Provides consistent, well-typed logging across different operational contexts. All logs are output in JSON format for better machine readability and parsing.
+A structured logging library with TypeScript support built on Pino. Provides consistent, well-typed logging across different operational contexts with automatic trace and span tracking. All logs are output in JSON format for better machine readability and parsing.
 
 ## Installation
 
@@ -11,60 +11,40 @@ npm install unnbound-logger
 ## Basic Usage
 
 ```typescript
-import { UnnboundLogger } from 'unnbound-logger';
-
-// Create a new logger instance
-const logger = new UnnboundLogger();
+import { logger } from 'unnbound-logger';
 
 // Log with string messages
 logger.info('Application started');
 logger.warn('Resource usage high');
-logger.error(new Error('Database connection failed'));
+logger.error({ err: new Error('Database connection failed') }, 'Something bad happened');
 logger.debug('Debug information');
 
-// Log with object messages (wrapped in 'data' field)
-logger.info({
-  event: 'user_login',
-  userId: '123',
-  timestamp: new Date().toISOString()
-});
-// Results in: { "data": { "event": "user_login", "userId": "123", "timestamp": "..." }, "message": "Structured log data", ... }
+// Log with object messages (merged into top level)
+logger.info({ event: 'user_login', userId: '123' }, 'Event received.');
+// Results in: { "event": "user_login", "userId": "123", "message": "Application started", ... }
 
-// Log with both string message and metadata (metadata added to top level)
-logger.info('User logged in', {
-  userId: '123',
-  timestamp: new Date().toISOString()
-});
-// Results in: { "userId": "123", "timestamp": "...", "message": "User logged in", ... }
-
-// Log with object message and additional metadata
-logger.info(
-  { event: 'user_login', userId: '123' },
-  { timestamp: new Date().toISOString() }
-);
-// Results in: { "data": { "event": "user_login", "userId": "123" }, "timestamp": "...", "message": "Structured log data", ... }
+// Log with both string message and metadata (metadata merged into top level)
+logger.info({ userId: '123' }, 'User logged in');
+// Results in: { "userId": "123", "message": "User logged in", ... }
 ```
 
 ## Log Format
 
-All logs follow a standardized format:
+All logs follow a standardized format based on Pino with additional context:
 
 ```typescript
 interface Log<T extends LogType = 'general'> {
-  logId: string; // Unique identifier for each log entry
   level: LogLevel; // "info" | "debug" | "error" | "warn"
-  type: T; // "general" | "httpRequest" | "httpResponse" | "sftpTransaction" | "dbQueryTransaction"
   message: string;
-  workflowId: string;
-  serviceId: string;
-  traceId: string;
-  requestId: string;
-  deploymentId: string; // Automatically populated from UNNBOUND_DEPLOYMENT_ID
-  error?: SerializableError; // Only present for Error objects
-}
-
-interface LogTransaction<T extends LogType> extends Log<T> {
-  duration: number; // Duration in milliseconds
+  traceId?: string; // Automatically included when in trace context
+  spanId?: string; // Automatically included when in span context
+  type?: T; // "general" | "http" | "sftp" | "dbQueryTransaction"
+  serviceId?: string; // From UNNBOUND_SERVICE_ID environment variable
+  deploymentId?: string; // From UNNBOUND_DEPLOYMENT_ID environment variable
+  workflowId?: string; // From UNNBOUND_WORKFLOW_ID environment variable
+  environment?: string; // From ENVIRONMENT environment variable
+  err?: unknown; // Only present for Error objects
+  duration?: number; // Duration in milliseconds for span operations
 }
 ```
 
@@ -80,15 +60,15 @@ export UNNBOUND_WORKFLOW_ID="order-processing-12345"
 export UNNBOUND_WORKFLOW_URL="https://workflows.example.com/order-processing-12345"
 export UNNBOUND_SERVICE_ID="order-service"
 
-# Or in your deployment configuration  
+# Or in your deployment configuration
 UNNBOUND_WORKFLOW_ID=order-processing-12345
 UNNBOUND_WORKFLOW_URL=https://workflows.example.com/order-processing-12345
 UNNBOUND_SERVICE_ID=order-service
 ```
 
 ```typescript
-// Create a logger - workflowId and serviceId are automatically set from environment
-const logger = new UnnboundLogger();
+// Import the logger - workflowId and serviceId are automatically set from environment
+import { logger } from 'unnbound-logger';
 ```
 
 ### Deployment Tracking
@@ -114,70 +94,47 @@ If the environment variables are not set, the fields will be empty strings. Thes
 
 ## Object Logging Behavior
 
-The logger handles different message types differently to ensure consistent structure in your logs:
+The logger uses Pino's standard behavior for handling different message types:
 
 ### String Messages with Metadata
-When you pass a string message with additional metadata, the metadata is wrapped in a `data` field:
+
+When you pass a string message with additional metadata, the metadata is merged into the top level:
 
 ```typescript
 logger.info('User action completed', { userId: '123', action: 'login' });
-// Result: { "message": "User action completed", "data": { "userId": "123", "action": "login" }, ... }
+// Result: { "message": "User action completed", "userId": "123", "action": "login", ... }
 ```
 
 ### Object Messages
-When you pass an object as the message, it gets wrapped in a `data` field to prevent unknown properties from polluting the top level:
-
-```typescript
-logger.info({ userId: '123', action: 'login', timestamp: '2025-01-01T12:00:00Z' });
-// Result: { "message": "Structured log data", "data": { "userId": "123", "action": "login", "timestamp": "2025-01-01T12:00:00Z" }, ... }
-```
 
-If the object contains a `message` property, it remains in the `data` object and doesn't affect the top-level message:
+When you pass an object as the message, it's merged into the top level:
 
 ```typescript
-logger.info({ message: 'Custom message', userId: '123' });
-// Result: { "message": "Structured log data", "data": { "message": "Custom message", "userId": "123" }, ... }
+logger.info({ userId: '123', action: 'login' });
+// Result: { "userId": "123", "action": "login", "message": "Application started", ... }
 ```
 
 ### Error Objects
+
 Error objects are handled specially and include serialized error information:
 
 ```typescript
-logger.error(new Error('Something went wrong'));
-// Result: { "message": "Error", "error": { "name": "Error", "message": "Something went wrong", "stack": "..." }, ... }
+logger.error({ err: new Error('Something went wrong') });
+// Result: { "message": "Error", "err": { "name": "Error", "message": "Something went wrong", "stack": "..." }, ... }
 ```
 
-This structure ensures your UI can reliably access all object data through the `data` field without worrying about unknown properties at the top level. Whether you pass an object as the message or as metadata, it will always be contained within the `data` field.
+This follows Pino's standard behavior where all object properties are merged into the top level of the log entry.
 
 ## HTTP Request/Response Logging
 
 ```typescript
-import { UnnboundLogger } from 'unnbound-logger';
+import { logger, traceMiddleware } from 'unnbound-logger';
 import express from 'express';
 
 const app = express();
-const logger = new UnnboundLogger();
-
-// Middleware to log requests
-app.use((req, res, next) => {
-  // Log the request and get the request ID
-  const requestId = logger.httpRequest(req, {
-    startTime: Date.now()
-  });
-
-  // Store the request ID in res.locals for later use
-  res.locals.requestId = requestId;
-
-  // Add response listener to log the response
-  res.on('finish', () => {
-    logger.httpResponse(res, req, {
-      requestId,
-      startTime: res.locals.startTime
-    });
-  });
-
-  next();
-});
+
+// Apply trace middleware for automatic HTTP logging
+app.use(traceMiddleware());
 
 // Example route
 app.post('/api/users', (req, res) => {
@@ -186,11 +143,13 @@ app.post('/api/users', (req, res) => {
 });
 ```
 
-The logger automatically captures:
+The trace middleware automatically captures:
+
 - Request method, URL, body, and headers (filtered for security)
 - Response status code, body, and headers (filtered for security)
 - Request duration
-- Trace ID and request ID for correlation
+- Trace ID and span ID for correlation
+- Automatic span tracking for the entire request lifecycle
 
 ### Full URL Logging for Webhook Endpoints
 
@@ -210,13 +169,12 @@ export UNNBOUND_WORKFLOW_URL="https://api.yourservice.com"
 
 ```typescript
 import express from 'express';
-import { UnnboundLogger } from 'unnbound-logger';
+import { traceMiddleware } from 'unnbound-logger';
 
 const app = express();
-const logger = new UnnboundLogger();
 
 // Apply trace middleware for automatic logging
-app.use(logger.traceMiddleware);
+app.use(traceMiddleware());
 
 // Webhook endpoints - URLs automatically logged with full domain
 app.post('/webhooks/stripe', (req, res) => {
@@ -232,67 +190,6 @@ app.post('/webhooks/github', (req, res) => {
 
 This ensures webhook logs contain the complete URL for easy debugging and monitoring.
 
-## SFTP Transaction Logging
-
-For logging SFTP operations:
-
-```typescript
-import { UnnboundLogger } from 'unnbound-logger';
-
-const logger = new UnnboundLogger();
-
-// Log an SFTP upload
-logger.sftpTransaction({
-  host: 'sftp.example.com',
-  username: 'ftpuser',
-  operation: 'upload',
-  path: '/uploads/file.txt',
-  status: 'success',
-  bytesTransferred: 1024
-});
-
-// Log an SFTP download with failure
-logger.sftpTransaction({
-  host: 'sftp.example.com',
-  username: 'ftpuser',
-  operation: 'download',
-  path: '/downloads/file.txt',
-  status: 'failure'
-}, {
-  startTime: Date.now() - 5000 // Started 5 seconds ago
-});
-```
-
-## Database Query Transaction Logging
-
-For logging database operations:
-
-```typescript
-import { UnnboundLogger } from 'unnbound-logger';
-
-const logger = new UnnboundLogger();
-
-// Log a successful database query
-logger.dbQueryTransaction({
-  instance: 'localhost:5432',
-  vendor: 'postgres',
-  query: 'SELECT * FROM users WHERE active = true',
-  status: 'success',
-  rowsReturned: 150
-});
-
-// Log a failed database operation
-logger.dbQueryTransaction({
-  instance: 'prod-db-cluster',
-  vendor: 'mysql',
-  query: 'UPDATE users SET last_login = NOW()',
-  status: 'failure',
-  rowsAffected: 0
-}, {
-  duration: 2500 // Operation took 2.5 seconds
-});
-```
-
 ## Middleware Usage
 
 ### Express Trace Middleware
@@ -300,155 +197,180 @@ logger.dbQueryTransaction({
 The library provides a comprehensive trace middleware for Express applications that automatically handles trace context and HTTP logging:
 
 ```typescript
-import { UnnboundLogger } from 'unnbound-logger';
+import { traceMiddleware } from 'unnbound-logger';
 import express from 'express';
 
 const app = express();
-const logger = new UnnboundLogger();
 
 // Apply the comprehensive trace middleware globally
-app.use(logger.traceMiddleware);
+app.use(traceMiddleware());
 ```
 
 The trace middleware automatically:
+
 - Generates and maintains trace IDs across the request lifecycle
-- Logs incoming requests with method, URL, headers, and body (filtered for security)
+- Logs incoming requests with method, URL, headers, and body
 - Logs outgoing responses with status code, headers, body, and duration
 - Measures request duration automatically
 - Handles errors and logs them appropriately
 - Captures response bodies for logging
+- Creates spans for the entire request lifecycle
 
 ### Axios Trace Middleware
 
 For comprehensive logging of outgoing HTTP requests made with Axios:
 
 ```typescript
-import { UnnboundLogger } from 'unnbound-logger';
+import { traceAxios } from 'unnbound-logger';
 import axios from 'axios';
 
-const logger = new UnnboundLogger();
-
-// Add both request and response interceptors for complete HTTP logging
-axios.interceptors.request.use(
-  logger.axiosTraceMiddleware.onFulfilled,
-  logger.axiosTraceMiddleware.onRejected
-);
-
-axios.interceptors.response.use(
-  logger.axiosResponseInterceptor.onFulfilled,
-  logger.axiosResponseInterceptor.onRejected
-);
+// Create an axios instance and wrap it with tracing
+const client = traceAxios(axios.create());
 
-// All requests made with axios will be automatically logged
-axios.get('https://api.example.com/data');
+// All requests made with this client will be automatically logged
+client.get('https://api.example.com/data');
 ```
 
 The Axios middleware:
-- Logs outgoing requests with method, URL, headers, and body (filtered for security)
+
+- Logs outgoing requests with method, URL, headers, and body
 - Maintains trace context across requests by propagating trace IDs
 - Logs successful responses with status, headers, body, and duration
 - Logs error responses with detailed error information
+- Creates spans for each HTTP request
 - Supports request/response filtering through configuration
 
-## Function Tracing with withTrace
+## Function Tracing with startSpan
 
-The `withTrace` higher-order function allows you to wrap any function with automatic trace context. This is particularly useful for maintaining consistent trace IDs across async operations and distributed systems:
+The `startSpan` function allows you to wrap any async operation with automatic span tracking and logging. This is particularly useful for maintaining consistent trace IDs across async operations and distributed systems:
 
 ```typescript
-import { UnnboundLogger } from 'unnbound-logger';
-import { withTrace } from 'unnbound-logger/utils/with-trace';
-import { traceContext } from 'unnbound-logger/utils/trace-context';
-
-const logger = new UnnboundLogger();
+import { logger, startSpan } from 'unnbound-logger';
 
-// Example: Wrapping a function with trace context
-const operation = (value: number) => {
-  const traceId = traceContext.getTraceId();
-  logger.info('Processing value', { value, traceId });
+// Example: Wrapping a function with span tracking
+const operation = async (value: number) => {
+  logger.info('Processing value', { value });
   return value * 2;
 };
 
-// Wrap the function with trace context
-const tracedOperation = withTrace(operation);
+// Wrap the function with span tracking
+const result = await startSpan('Processing operation', operation, () => ({
+  operationType: 'calculation',
+}));
 
 // Execute the function
-const result = tracedOperation(21); // Returns 42
-```
-
-### Using Custom Trace IDs
-
-You can provide your own trace ID when wrapping a function:
-
-```typescript
-const customTraceId = 'custom-trace-123';
-const tracedOperation = withTrace(operation, customTraceId);
+const result = await startSpan('Processing operation', () => operation(21)); // Returns 42
 ```
 
 ### Async Operations
 
-The trace context is maintained across async operations:
+The span context is maintained across async operations:
 
 ```typescript
 const asyncOperation = async (value: number) => {
-  const traceId1 = traceContext.getTraceId();
-  logger.info('First step', { traceId: traceId1 });
+  logger.info('First step', { value });
 
   await someAsyncWork();
 
-  const traceId2 = traceContext.getTraceId();
-  logger.info('Second step', { traceId: traceId2 });
-  // traceId1 and traceId2 will be the same
+  logger.info('Second step', { value });
+  return value * 2;
 };
 
-const tracedOperation = withTrace(asyncOperation);
-await tracedOperation(42);
+const result = await startSpan('Async operation', asyncOperation, () => ({
+  operationType: 'async_calculation',
+}));
 ```
 
 ### Benefits
 
-- Automatic trace ID generation
+- Automatic span ID generation and tracking
 - Consistent trace context across async operations
-- Support for custom trace IDs
+- Automatic duration measurement
+- Error handling and logging
 - Type-safe implementation
-- Works with both sync and async functions
-- Maintains separate trace contexts for different operations
-
-> **Note:** When using `UnnboundLogger`, you don't need to manually call `traceContext.getTraceId()` in your logging calls. The logger automatically includes the current trace ID in all log entries. The example above shows manual trace ID retrieval for demonstration purposes, but in practice, you can simply use the logger methods directly:
->
-> ```typescript
-> const operation = (value: number) => {
->   logger.info('Processing value', { value }); // Trace ID is automatically included
->   return value * 2;
-> };
-> ```
+- Works with async functions
+- Maintains separate span contexts for different operations
+
+> **Note:** When using the logger within spans, you don't need to manually manage trace IDs. The logger automatically includes the current trace ID and span ID in all log entries.
 
 ## API Reference
 
-### UnnboundLogger
+### logger
 
-The main logger class that provides all logging functionality using Pino.
+The main logger instance that provides all logging functionality using Pino.
 
-#### Constructor
+#### Usage
 
 ```typescript
-new UnnboundLogger(options?: LoggerOptions)
+import { logger } from 'unnbound-logger';
 ```
 
-**LoggerOptions:**
-- `traceHeaderKey?: string` - Custom trace header name (default: 'unnbound-trace-id')
-- `ignoreTraceRoutes?: string[]` - Routes to ignore in Express middleware
-- `ignoreAxiosTraceRoutes?: string[]` - Routes to ignore in Axios middleware
-
-**Note:** `workflowId`, `serviceId`, and `deploymentId` are configured via environment variables (`UNNBOUND_WORKFLOW_ID`, `UNNBOUND_SERVICE_ID`, `UNNBOUND_DEPLOYMENT_ID`). The `UNNBOUND_WORKFLOW_URL` is used for URL construction in webhook endpoints.
+The logger is a Pino instance with additional context automatically included from environment variables and trace context.
 
 #### Methods
 
-- `log(level: LogLevel, message: string | Error | Record<string, unknown>, options?: GeneralLogOptions): Log`
-- `error(message: string | Error | Record<string, unknown>, options?: GeneralLogOptions): Log`
-- `warn(message: string | Error | Record<string, unknown>, options?: GeneralLogOptions): Log`
-- `info(message: string | Error | Record<string, unknown>, options?: GeneralLogOptions): Log`
-- `debug(message: string | Error | Record<string, unknown>, options?: GeneralLogOptions): Log`
-- `httpRequest(req: Request, options?: HttpRequestLogOptions): HttpRequestLog`
-- `httpResponse(res: Response, req: Request, options: HttpResponseLogOptions): HttpResponseLog`
-- `sftpTransaction(operation: SftpOperation, options?: SftpTransactionLogOptions): SftpTransactionLog`
-- `dbQueryTransaction(query: DbQuery, options?: DbQueryTransactionLogOptions): DbQueryTransactionLog`
+- `logger.info(object: {}, message: string): void`
+- `logger.warn(object: {}, message: string): void`
+- `logger.error(object: {}, message: string): void`
+- `logger.debug(object: {}, message: string): void`
+
+### traceMiddleware
+
+Express middleware for automatic HTTP request/response logging and trace context management.
+
+#### Usage
+
+```typescript
+import { traceMiddleware } from 'unnbound-logger';
+
+app.use(traceMiddleware(options?: HttpOptions));
+```
+
+**HttpOptions:**
+
+- `traceHeaderKey?: string` - Custom trace header name (default: 'x-unnbound-trace-id')
+- `ignoreTraceRoutes?: string[]` - Routes to ignore in middleware (default: ['/health', '/healthcheck'])
+
+### traceAxios
+
+Wraps an Axios instance with automatic request/response logging and trace context propagation.
+
+#### Usage
+
+```typescript
+import { traceAxios } from 'unnbound-logger';
+import axios from 'axios';
+
+const client = traceAxios(axios.create(), options?: HttpOptions);
+```
+
+### startSpan
+
+Creates a span for tracking async operations with automatic logging and duration measurement.
+
+#### Usage
+
+```typescript
+import { startSpan } from 'unnbound-logger';
+
+const result = await startSpan<T>(
+  spanName: string,
+  callback: () => Promise<T>,
+  getter?: LogPayloadGetter<T>
+);
+```
+
+**Parameters:**
+
+- `spanName`: The name of the span for logging
+- `callback`: The async function to execute within the span
+- `getter`: Optional function to generate log payload based on operation result/error
+
+### Environment Variables
+
+- `UNNBOUND_WORKFLOW_ID` - Workflow identifier (included in all logs)
+- `UNNBOUND_SERVICE_ID` - Service identifier (included in all logs)
+- `UNNBOUND_DEPLOYMENT_ID` - Deployment identifier (included in all logs)
+- `UNNBOUND_WORKFLOW_URL` - Base URL for webhook endpoint logging
+- `ENVIRONMENT` - Environment name (included in all logs)
+- `LOG_LEVEL` - Log level (default: 'info')

package/dist/axios.d.ts

@@ -0,0 +1,9 @@
+import { Axios } from 'axios';
+import { HttpOptions } from './types';
+/**
+ * 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: Axios, { ignoreTraceRoutes, traceHeaderKey, }?: HttpOptions) => Axios;

package/dist/axios.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceAxios = void 0;
+const axios_1 = require("axios");
+const types_1 = require("./types");
+const storage_1 = require("./storage");
+const utils_1 = require("./utils");
+const span_1 = require("./span");
+const buildOutgoingHttpPayload = (config, res) => ({
+    type: 'http',
+    http: {
+        url: [config.baseURL, config.url].filter(Boolean).join(''),
+        method: config.method?.toUpperCase() || 'GET',
+        incoming: false,
+        request: {
+            headers: config.headers,
+            body: (0, utils_1.safeJsonParse)(config.data),
+        },
+        response: res
+            ? {
+                headers: res?.headers,
+                status: res.status,
+                body: (0, utils_1.safeJsonParse)(res.data),
+            }
+            : undefined,
+    },
+});
+/**
+ * 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, } = {
+    ignoreTraceRoutes: types_1.defaultIgnoreTraceRoutes,
+    traceHeaderKey: types_1.defaultTraceHeaderKey,
+}) => {
+    const createSpanWrappedRequest = (originalMethod, method) => {
+        const { headers: defaultHeaders, ...partialDefaultConfig } = client.defaults;
+        const headers = { ...defaultHeaders.common, ...(method && defaultHeaders[method]) };
+        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('');
+            // Check if this request should be ignored
+            if ((0, utils_1.shouldIgnorePath)(url, ignoreTraceRoutes))
+                return originalMethod(config);
+            const traceId = storage_1.storage.getStore()?.[storage_1.ContextAttribute.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) => {
+                if (!options)
+                    return buildOutgoingHttpPayload(config);
+                if (options.error)
+                    return buildOutgoingHttpPayload(config, (0, axios_1.isAxiosError)(options.error) ? options.error.response : undefined);
+                return buildOutgoingHttpPayload(config, options.result);
+            });
+        };
+    };
+    const request = client.request.bind(client);
+    const tracedRequest = createSpanWrappedRequest(request);
+    client.request = tracedRequest;
+    ['post', 'put', 'patch'].forEach((method) => {
+        const func = createSpanWrappedRequest(request, method);
+        client[method] = (url, data, config) => func({ ...config, url, data });
+    });
+    ['delete', 'get', 'head', 'options'].forEach((method) => {
+        const func = createSpanWrappedRequest(request, method);
+        client[method] = (url, config) => func({ ...config, url });
+    });
+    return client;
+};
+exports.traceAxios = traceAxios;

package/dist/http.js

@@ -0,0 +1 @@
+"use strict";

package/dist/index.d.ts

@@ -4,7 +4,9 @@
  * A structured logging library built on Pino with TypeScript support.
  * Provides consistent, well-typed logging across different operational contexts.
  */
-import { UnnboundLogger } from './unnbound-logger';
-import { LogLevel, LogType, HttpMethod, LoggerOptions, GeneralLogOptions, HttpRequestLogOptions, HttpResponseLogOptions, SftpTransactionLogOptions, DbQueryTransactionLogOptions, Log, LogTransaction, HttpRequestLog, HttpResponseLog, SftpTransactionLog, DbQueryTransactionLog, SerializableError } from './types';
-import { clearTraceId } from './utils/logger-utils';
-export { UnnboundLogger, LogLevel, LogType, HttpMethod, LoggerOptions, GeneralLogOptions, HttpRequestLogOptions, HttpResponseLogOptions, SftpTransactionLogOptions, DbQueryTransactionLogOptions, Log, LogTransaction, HttpRequestLog, HttpResponseLog, SftpTransactionLog, DbQueryTransactionLog, SerializableError, clearTraceId, };
+export type { LogLevel, LogType, HttpMethod, Log, LogTransaction, SftpLog, HttpLog, SftpPayload, } from './types';
+export type { UnnboundLogger } from './logger';
+export { logger } from './logger';
+export { startSpan } from './span';
+export { traceAxios } from './axios';
+export { traceMiddleware } from './middleware';