unnbound-logger-sdk 2.0.9 → 3.0.0

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,57 +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
-logger.info({
-  event: 'user_login',
-  userId: '123',
-  timestamp: new Date().toISOString()
-});
-
-// Log with both string message and metadata
-logger.info('User logged in', {
-  userId: '123',
-  timestamp: new Date().toISOString()
-});
+// 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 object message and additional metadata
-logger.info(
-  { event: 'user_login', userId: '123' },
-  { timestamp: new Date().toISOString() }
-);
+// 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
 }
 ```
 
@@ -77,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
@@ -109,35 +92,49 @@ If the environment variables are not set, the fields will be empty strings. Thes
 - **Correlating issues**: Link problems to specific workflows and releases
 - **Monitoring**: Track health and performance across workflows and deployments
 
+## Object Logging Behavior
+
+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 merged into the top level:
+
+```typescript
+logger.info('User action completed', { userId: '123', action: 'login' });
+// Result: { "message": "User action completed", "userId": "123", "action": "login", ... }
+```
+
+### Object Messages
+
+When you pass an object as the message, it's merged into the top level:
+
+```typescript
+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({ err: new Error('Something went wrong') });
+// Result: { "message": "Error", "err": { "name": "Error", "message": "Something went wrong", "stack": "..." }, ... }
+```
+
+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) => {
@@ -146,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
 
@@ -170,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) => {
@@ -192,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
@@ -260,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/index.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearTraceId = exports.UnnboundLogger = void 0;
-/**
- * unnbound-logger
- *
- * A structured logging library built on Pino with TypeScript support.
- * Provides consistent, well-typed logging across different operational contexts.
- */
-const unnbound_logger_1 = require("./unnbound-logger");
-Object.defineProperty(exports, "UnnboundLogger", { enumerable: true, get: function () { return unnbound_logger_1.UnnboundLogger; } });
-const logger_utils_1 = require("./utils/logger-utils");
-Object.defineProperty(exports, "clearTraceId", { enumerable: true, get: function () { return logger_utils_1.clearTraceId; } });
+exports.traceMiddleware = exports.traceAxios = exports.startSpan = exports.logger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
+var span_1 = require("./span");
+Object.defineProperty(exports, "startSpan", { enumerable: true, get: function () { return span_1.startSpan; } });
+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; } });

package/package.json

@@ -1,23 +1,9 @@
 {
   "name": "unnbound-logger-sdk",
-  "version": "2.0.9",
   "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.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "test": "npx jest",
-    "test:coverage": "npx jest --coverage",
-    "test:watch": "npx jest --watch",
-    "lint": "eslint src/**/*.ts",
-    "lint:fix": "eslint . --ext .ts --fix",
-    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
-    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
-    "prepublishOnly": "npm run build && npm test",
-    "check-coverage": "ts-node scripts/check-coverage.ts",
-    "start:example:node-app": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' examples/node-app.ts",
-    "start:example:basic-usage": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' examples/basic-usage.ts"
-  },
   "keywords": [
     "logging",
     "typescript",
@@ -33,11 +19,11 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/unnbound/logger.git"
+    "url": "https://github.com/unnbounddev/unnbound-sdks.git"
   },
-  "homepage": "https://github.com/unnbound/logger#readme",
+  "homepage": "https://github.com/unnbounddev/unnbound-sdks#readme",
   "bugs": {
-    "url": "https://github.com/unnbound/logger/issues"
+    "url": "https://github.com/unnbounddev/unnbound-sdks/issues"
   },
   "dependencies": {
     "axios": "^1.0.0",
@@ -49,19 +35,7 @@
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.11.24",
-    "@types/uuid": "^9.0.8",
-    "@typescript-eslint/eslint-plugin": "^7.1.0",
-    "@typescript-eslint/parser": "^7.1.0",
-    "cors": "^2.8.5",
-    "dotenv": "^16.5.0",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^10.1.5",
-    "jest": "^29.7.0",
-    "nodemon": "^3.1.10",
-    "prettier": "^3.2.5",
-    "ts-jest": "^29.1.2",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.3.3"
+    "@types/uuid": "^9.0.8"
   },
   "peerDependencies": {
     "axios": "^1.0.0",
@@ -77,14 +51,23 @@
   },
   "files": [
     "dist/src/**/*",
-    "dist/index.*",
-    "dist/types.*",
-    "dist/unnbound-logger.*",
-    "dist/utils/**/*",
     "README.md",
     "LICENSE"
   ],
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=22.0.0"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch",
+    "lint": "eslint --cache --cache-location ./node_modules/.cache/eslint .",
+    "lint:fix": "pnpm lint --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "start:example:node-app": "npx tsx --watch examples/node-app.ts",
+    "start:example:basic-usage": "npx tsx --watch examples/basic-usage.ts"
   }
-}
+}

package/dist/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * unnbound-logger
- *
- * 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, };