unnbound-logger-sdk 2.0.9 → 2.0.10

package/README.md

@@ -22,24 +22,27 @@ logger.warn('Resource usage high');
 logger.error(new Error('Database connection failed'));
 logger.debug('Debug information');
 
-// Log with object messages
+// 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 both string message and metadata
+// 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 Format
@@ -109,6 +112,43 @@ 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 handles different message types differently to ensure consistent structure in your logs:
+
+### String Messages with Metadata
+When you pass a string message with additional metadata, the metadata is wrapped in a `data` field:
+
+```typescript
+logger.info('User action completed', { userId: '123', action: 'login' });
+// Result: { "message": "User action completed", "data": { "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:
+
+```typescript
+logger.info({ message: 'Custom message', userId: '123' });
+// Result: { "message": "Structured log data", "data": { "message": "Custom message", "userId": "123" }, ... }
+```
+
+### 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": "..." }, ... }
+```
+
+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.
+
 ## HTTP Request/Response Logging
 
 ```typescript

package/dist/unnbound-logger.js

@@ -227,6 +227,8 @@ class UnnboundLogger {
         const requestId = options.requestId || (0, uuid_1.v4)();
         let logEntry;
         const { traceId: optionTraceId, requestId: optionRequestId, level: optionLevel, ...restOptions } = options;
+        // If restOptions has any properties, we'll add them to data later
+        const hasRestOptions = Object.keys(restOptions).length > 0;
         const baseEntry = {
             logId,
             type: 'general',
@@ -246,23 +248,23 @@ class UnnboundLogger {
                 ...baseEntry,
                 message: message.name,
                 error,
-                ...restOptions,
+                ...(hasRestOptions && { data: restOptions }),
             };
         }
         else if (typeof message === 'string') {
             logEntry = {
                 ...baseEntry,
                 message,
-                ...restOptions,
+                ...(hasRestOptions && { data: restOptions }),
             };
         }
         else {
-            // If message is an object, it's part of the log entry
+            // If message is an object, wrap it in a 'data' key
+            const messageObj = message;
             logEntry = {
                 ...baseEntry,
-                ...message,
-                message: message.message || 'Structured log data',
-                ...restOptions,
+                message: 'Structured log data',
+                data: hasRestOptions ? { ...messageObj, ...restOptions } : messageObj,
             };
         }
         // Separate the message from the log data and explicitly exclude any level field

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unnbound-logger-sdk",
-  "version": "2.0.9",
+  "version": "2.0.10",
   "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.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",