@jaypie/logger 1.2.10 → 1.2.12

package/dist/cjs/Logger.d.ts

@@ -4,6 +4,7 @@ type Tags = Record<string, string>;
 interface LoggerOptions {
     format?: LogFormat;
     level?: LogLevel;
+    levelField?: boolean | string;
     tags?: Tags;
     varLevel?: LogLevel;
 }
@@ -21,7 +22,8 @@ declare class Logger {
     trace: LogMethod;
     var: (messageObject: unknown, messageValue?: unknown) => void;
     warn: LogMethod;
-    constructor({ format, level, tags, varLevel, }?: LoggerOptions);
+    private levelField;
+    constructor({ format, level, levelField, tags, varLevel, }?: LoggerOptions);
     private createLogMethod;
     tag(key: unknown, value?: unknown): void;
     untag(key: unknown): void;

package/dist/cjs/index.cjs

@@ -63,6 +63,224 @@ const DATADOG_TRANSPORT = {
     MAX_BATCH_SIZE: 100,
 };
 
+//
+// Key-based pipelines (match on var key name)
+//
+function isAxiosResponse(response) {
+    if (typeof response !== "object" || response === null) {
+        return false;
+    }
+    const r = response;
+    return !!(r &&
+        r.config &&
+        r.data &&
+        r.headers &&
+        r.request &&
+        r.status &&
+        r.statusText);
+}
+function filterAxiosResponse(response) {
+    if (!isAxiosResponse(response)) {
+        return response;
+    }
+    const r = response;
+    const newResponse = {
+        data: r.data,
+        headers: r.headers,
+        status: r.status,
+        statusText: r.statusText,
+    };
+    if (r.isAxiosError) {
+        newResponse.isAxiosError = r.isAxiosError;
+    }
+    return newResponse;
+}
+const axiosResponseVarPipeline = {
+    filter: filterAxiosResponse,
+    key: "response",
+};
+const pipelines = [axiosResponseVarPipeline];
+// Fetch Response
+function isFetchResponse(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const r = value;
+    return !!(typeof r.ok === "boolean" &&
+        typeof r.status === "number" &&
+        typeof r.statusText === "string" &&
+        "headers" in r &&
+        "body" in r &&
+        typeof r.url === "string" &&
+        !("config" in r) &&
+        !("request" in r));
+}
+function headersToObject(headers) {
+    if (headers &&
+        typeof headers === "object" &&
+        typeof headers.entries === "function") {
+        const result = {};
+        for (const [key, value] of headers.entries()) {
+            result[key] = value;
+        }
+        return result;
+    }
+    return headers;
+}
+function filterFetchResponse(value) {
+    const r = value;
+    return {
+        headers: headersToObject(r.headers),
+        ok: r.ok,
+        redirected: r.redirected,
+        status: r.status,
+        statusText: r.statusText,
+        type: r.type,
+        url: r.url,
+    };
+}
+// Error
+function isError(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    if (value instanceof Error) {
+        return true;
+    }
+    const i = value;
+    if (i.isProjectError) {
+        return true;
+    }
+    return false;
+}
+function filterError(value) {
+    const e = value;
+    const newItem = {
+        message: e.message,
+        name: e.name,
+    };
+    if (e.cause) {
+        newItem.cause = e.cause;
+    }
+    if (e.stack) {
+        newItem.stack = e.stack;
+    }
+    if (e.isProjectError) {
+        newItem.isProjectError = e.isProjectError;
+        newItem.title = e.title;
+        newItem.detail = e.detail;
+        newItem.status = e.status;
+    }
+    return newItem;
+}
+// Type filter registry (order matters — first match wins)
+const typeFilters = [
+    { detect: isFetchResponse, filter: filterFetchResponse },
+    { detect: isError, filter: filterError },
+];
+//
+// Opaque object detection and generic extraction
+//
+function isOpaqueObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    // Plain objects are fine
+    if (value.constructor === Object || value.constructor === undefined) {
+        return false;
+    }
+    // If JSON.stringify produces "{}" the object has no own enumerable properties
+    // and will log as useless "[object Type]"
+    try {
+        const json = JSON.stringify(value);
+        return json === "{}" || json === "[]";
+    }
+    catch {
+        return true;
+    }
+}
+function extractOpaqueObject(value) {
+    const obj = value;
+    const result = {};
+    const ctorName = obj.constructor?.name;
+    if (ctorName && ctorName !== "Object") {
+        result._type = ctorName;
+    }
+    // If the object itself is map-like (Headers, URLSearchParams, FormData, etc.),
+    // convert its entries directly
+    const mapLike = obj;
+    if (typeof mapLike.entries === "function" &&
+        typeof mapLike.forEach === "function") {
+        try {
+            const entries = Object.fromEntries(mapLike.entries());
+            return { ...result, ...entries };
+        }
+        catch {
+            // Fall through to generic extraction
+        }
+    }
+    // Collect readable non-function properties from the prototype chain
+    let proto = obj;
+    while (proto && proto !== Object.prototype) {
+        for (const key of Object.getOwnPropertyNames(proto)) {
+            if (key === "constructor" || key in result) {
+                continue;
+            }
+            try {
+                const desc = Object.getOwnPropertyDescriptor(proto, key);
+                if (!desc)
+                    continue;
+                // Read getters and value properties from the original object
+                const val = obj[key];
+                if (typeof val === "function" || typeof val === "symbol") {
+                    continue;
+                }
+                // Skip streams and other non-serializable objects
+                if (val &&
+                    typeof val === "object" &&
+                    typeof val.pipe === "function") {
+                    continue;
+                }
+                // Convert iterable map-like objects (Headers, URLSearchParams, etc.)
+                if (val &&
+                    typeof val === "object" &&
+                    typeof val.entries === "function" &&
+                    typeof val.forEach === "function") {
+                    result[key] = Object.fromEntries(val.entries());
+                    continue;
+                }
+                result[key] = val;
+            }
+            catch {
+                // Property threw on access — skip
+            }
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return result;
+}
+//
+// Public API
+//
+/**
+ * Filter a value by type, regardless of var key name.
+ * Tries known type filters first, then falls back to generic
+ * opaque object extraction for anything that would log as [object Type].
+ */
+function filterByType(value) {
+    // Try known type filters
+    for (const tf of typeFilters) {
+        if (tf.detect(value)) {
+            return tf.filter(value);
+        }
+    }
+    // Generic fallback for opaque objects
+    if (isOpaqueObject(value)) {
+        return extractOpaqueObject(value);
+    }
+    return value;
+}
+
 //
 //
 // Helper
@@ -407,11 +625,30 @@ function parsesTo(message) {
     }
 }
 
+function resolveLevelField(value) {
+    if (value === undefined) {
+        const env = process.env.LOG_LEVEL_FIELD;
+        if (env === undefined || env === "")
+            return false;
+        if (env === "false" || env === "0" || env === "no")
+            return false;
+        if (env === "true" || env === "1" || env === "yes")
+            return "level";
+        return env;
+    }
+    if (value === false)
+        return false;
+    if (value === true)
+        return "level";
+    return value;
+}
 class Logger {
-    constructor({ format = process.env.LOG_FORMAT || DEFAULT.LEVEL, level = process.env.LOG_LEVEL || DEFAULT.LEVEL, tags = {}, varLevel = process.env.LOG_VAR_LEVEL || DEFAULT.VAR_LEVEL, } = {}) {
+    constructor({ format = process.env.LOG_FORMAT || DEFAULT.LEVEL, level = process.env.LOG_LEVEL || DEFAULT.LEVEL, levelField, tags = {}, varLevel = process.env.LOG_VAR_LEVEL || DEFAULT.VAR_LEVEL, } = {}) {
+        this.levelField = resolveLevelField(levelField);
         this.options = {
             format,
             level,
+            levelField: this.levelField || undefined,
             varLevel,
         };
         this.tags = {};
@@ -441,6 +678,9 @@ class Logger {
                     if (parses.parses) {
                         json.data = parses.message;
                     }
+                    if (this.levelField) {
+                        json[this.levelField] = logLevel;
+                    }
                     out(json, { level: logLevel });
                 }
                 else {
@@ -479,7 +719,13 @@ class Logger {
             }
             if (format === FORMAT.JSON) {
                 const messageKey = keys[0];
-                const messageVal = msgObj[messageKey];
+                let messageVal = msgObj[messageKey];
+                for (const pipeline of pipelines) {
+                    if (messageKey === pipeline.key) {
+                        messageVal = pipeline.filter(messageVal);
+                    }
+                }
+                messageVal = filterByType(messageVal);
                 const json = {
                     data: parse(messageVal),
                     dataType: typeof messageVal,
@@ -487,6 +733,9 @@ class Logger {
                     var: messageKey,
                     ...this.tags,
                 };
+                if (this.levelField) {
+                    json[this.levelField] = logLevel;
+                }
                 if (LEVEL_VALUES[logLevel] <= LEVEL_VALUES[checkLevel]) {
                     out(json, { level: logLevel });
                 }
@@ -598,81 +847,6 @@ function forceVar(key, value) {
     }
 }
 
-function isAxiosResponse(response) {
-    if (typeof response !== "object" || response === null) {
-        return false;
-    }
-    const r = response;
-    return !!(r &&
-        r.config &&
-        r.data &&
-        r.headers &&
-        r.request &&
-        r.status &&
-        r.statusText);
-}
-function filterAxiosResponse(response) {
-    if (!isAxiosResponse(response)) {
-        return response;
-    }
-    const r = response;
-    const newResponse = {
-        data: r.data,
-        headers: r.headers,
-        status: r.status,
-        statusText: r.statusText,
-    };
-    if (r.isAxiosError) {
-        newResponse.isAxiosError = r.isAxiosError;
-    }
-    return newResponse;
-}
-const axiosResponseVarPipeline = {
-    filter: filterAxiosResponse,
-    key: "response",
-};
-function isError(item) {
-    if (typeof item !== "object" || item === null) {
-        return false;
-    }
-    if (item instanceof Error) {
-        return true;
-    }
-    const i = item;
-    if (i.isProjectError) {
-        return true;
-    }
-    return false;
-}
-function filterErrorVar(item) {
-    if (!isError(item)) {
-        return item;
-    }
-    const e = item;
-    const newItem = {
-        message: e.message,
-        name: e.name,
-    };
-    if (e.cause) {
-        newItem.cause = e.cause;
-    }
-    if (e.stack) {
-        newItem.stack = e.stack;
-    }
-    if (e.isProjectError) {
-        newItem.isProjectError = e.isProjectError;
-        newItem.title = e.title;
-        newItem.detail = e.detail;
-        newItem.status = e.status;
-    }
-    return newItem;
-}
-const errorVarPipeline = {
-    filter: filterErrorVar,
-    key: "error",
-};
-const pipelines = [axiosResponseVarPipeline, errorVarPipeline];
-
 function keyValueToArray(keyValue) {
     const key = Object.keys(keyValue)[0];
     return [key, keyValue[key]];
@@ -684,6 +858,7 @@ function logVar(key, value) {
             v = pipeline.filter(v);
         }
     }
+    v = filterByType(v);
     return { [k]: v };
 }