@jaypie/logger 1.2.11 → 1.2.13

package/dist/esm/index.js

@@ -59,6 +59,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
@@ -497,7 +715,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,
@@ -619,81 +843,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]];
@@ -705,6 +854,7 @@ function logVar(key, value) {
             v = pipeline.filter(v);
         }
     }
+    v = filterByType(v);
     return { [k]: v };
 }
 
@@ -722,6 +872,10 @@ function envBoolean(key, { defaultValue }) {
 }
 class JaypieLogger {
     constructor({ level = process.env.LOG_LEVEL, tags = {}, } = {}) {
+        this._errorCount = 0;
+        this._report = {};
+        this._sessionActive = false;
+        this._warnCount = 0;
         this._params = { level, tags };
         this._loggers = [];
         this._tags = {};
@@ -736,16 +890,32 @@ class JaypieLogger {
         this._loggers = [this._logger];
         this.debug = ((...args) => this._logger.debug(...args));
         this.debug.var = (messageObject, messageValue) => this._logger.debug.var(messageObject, messageValue);
-        this.error = ((...args) => this._logger.error(...args));
-        this.error.var = (messageObject, messageValue) => this._logger.error.var(messageObject, messageValue);
+        this.error = ((...args) => {
+            if (this._sessionActive)
+                this._errorCount++;
+            this._logger.error(...args);
+        });
+        this.error.var = (messageObject, messageValue) => {
+            if (this._sessionActive)
+                this._errorCount++;
+            this._logger.error.var(messageObject, messageValue);
+        };
         this.fatal = ((...args) => this._logger.fatal(...args));
         this.fatal.var = (messageObject, messageValue) => this._logger.fatal.var(messageObject, messageValue);
         this.info = ((...args) => this._logger.info(...args));
         this.info.var = (messageObject, messageValue) => this._logger.info.var(messageObject, messageValue);
         this.trace = ((...args) => this._logger.trace(...args));
         this.trace.var = (messageObject, messageValue) => this._logger.trace.var(messageObject, messageValue);
-        this.warn = ((...args) => this._logger.warn(...args));
-        this.warn.var = (messageObject, messageValue) => this._logger.warn.var(messageObject, messageValue);
+        this.warn = ((...args) => {
+            if (this._sessionActive)
+                this._warnCount++;
+            this._logger.warn(...args);
+        });
+        this.warn.var = (messageObject, messageValue) => {
+            if (this._sessionActive)
+                this._warnCount++;
+            this._logger.warn.var(messageObject, messageValue);
+        };
         this.var = (messageObject, messageValue) => this._logger.var(logVar(messageObject, messageValue));
     }
     init() {
@@ -766,6 +936,11 @@ class JaypieLogger {
         });
         this._loggers = [this._logger];
         this._withLoggers = {};
+        // Reset session state
+        this._errorCount = 0;
+        this._report = {};
+        this._sessionActive = false;
+        this._warnCount = 0;
         const levels = [
             "debug",
             "error",
@@ -775,12 +950,38 @@ class JaypieLogger {
             "warn",
         ];
         levels.forEach((lvl) => {
-            this[lvl] = ((...args) => {
-                this._logger[lvl](...args);
-            });
-            this[lvl].var = (messageObject, messageValue) => {
-                this._logger[lvl].var(messageObject, messageValue);
-            };
+            if (lvl === "error") {
+                this.error = ((...args) => {
+                    if (this._sessionActive)
+                        this._errorCount++;
+                    this._logger.error(...args);
+                });
+                this.error.var = (messageObject, messageValue) => {
+                    if (this._sessionActive)
+                        this._errorCount++;
+                    this._logger.error.var(messageObject, messageValue);
+                };
+            }
+            else if (lvl === "warn") {
+                this.warn = ((...args) => {
+                    if (this._sessionActive)
+                        this._warnCount++;
+                    this._logger.warn(...args);
+                });
+                this.warn.var = (messageObject, messageValue) => {
+                    if (this._sessionActive)
+                        this._warnCount++;
+                    this._logger.warn.var(messageObject, messageValue);
+                };
+            }
+            else {
+                this[lvl] = ((...args) => {
+                    this._logger[lvl](...args);
+                });
+                this[lvl].var = (messageObject, messageValue) => {
+                    this._logger[lvl].var(messageObject, messageValue);
+                };
+            }
         });
     }
     lib({ level, lib, tags = {}, } = {}) {
@@ -806,12 +1007,55 @@ class JaypieLogger {
         this._loggers.push(logger._logger);
         return logger;
     }
+    report(data) {
+        if (!this._sessionActive) {
+            this.warn("[logger] report() called without active session");
+            return;
+        }
+        for (const key of Object.keys(data)) {
+            if (key in this._report) {
+                this.warn(`[logger] Overwriting report key: ${key}`);
+            }
+        }
+        Object.assign(this._report, data);
+    }
+    setup(tags) {
+        if (this._sessionActive) {
+            this.warn("[logger] setup() called while session already active");
+        }
+        this._errorCount = 0;
+        this._report = {};
+        this._sessionActive = true;
+        this._warnCount = 0;
+        if (tags) {
+            this.tag(tags);
+        }
+    }
     tag(tags) {
         for (const logger of this._loggers) {
             logger.tag(tags);
         }
         Object.assign(this._tags, tags);
     }
+    teardown() {
+        if (!this._sessionActive) {
+            return;
+        }
+        const finalReport = {
+            ...this._report,
+            log: {
+                error: this._errorCount > 0,
+                errors: this._errorCount,
+                warn: this._warnCount > 0,
+                warns: this._warnCount,
+            },
+        };
+        this.info.var({ report: finalReport });
+        this._errorCount = 0;
+        this._report = {};
+        this._sessionActive = false;
+        this._warnCount = 0;
+    }
     untag(key) {
         for (const logger of this._loggers) {
             logger.untag(key);