@friggframework/core 2.0.0--canary.652.b14f3b5.0 → 2.0.0--canary.654.42e42b2.0

package/logs/logger-runtime.js

@@ -0,0 +1,142 @@
+const { LEVELS, parseLevel, resolveLevel } = require('./levels');
+
+// On globalThis so jest.resetModules and nested core copies share one state.
+const STATE_KEY = Symbol.for('@friggframework/core.logs');
+
+function state() {
+    if (!globalThis[STATE_KEY]) {
+        globalThis[STATE_KEY] = {
+            config: null,
+            levelOverride: null,
+            sinks: null,
+            spanContextProvider: null,
+            warned: new Set(),
+            inLog: false,
+            trackViolations: false,
+            violations: [],
+        };
+    }
+    return globalThis[STATE_KEY];
+}
+
+function readEnv(name) {
+    const value = process.env[name];
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+
+function getConfig() {
+    const s = state();
+    if (!s.config) {
+        const resolved = s.levelOverride
+            ? { level: s.levelOverride, warnings: [] }
+            : resolveLevel(process.env);
+        s.config = {
+            level: resolved.level,
+            threshold: LEVELS[resolved.level],
+            appName: readEnv('FRIGG_STACK'),
+            stage: readEnv('STAGE'),
+            pendingWarnings: resolved.warnings,
+        };
+    }
+    return s.config;
+}
+
+function takeConfigWarnings() {
+    const s = state();
+    const config = getConfig();
+    const pending = config.pendingWarnings.splice(0);
+    return pending.filter((warning) => {
+        if (s.warned.has(warning.eventName)) return false;
+        s.warned.add(warning.eventName);
+        return true;
+    });
+}
+
+function getSinks() {
+    const s = state();
+    if (!s.sinks) {
+        s.sinks = [require('./sinks').createStdoutSink()];
+    }
+    return s.sinks;
+}
+
+function setSinks(sinks) {
+    state().sinks = Array.isArray(sinks) ? [...sinks] : null;
+}
+
+function hasFlushableSinks() {
+    return getSinks().some((sink) => typeof sink.flush === 'function');
+}
+
+async function flushSinks({ signal } = {}) {
+    const flushes = getSinks()
+        .filter((sink) => typeof sink.flush === 'function')
+        .map((sink) => {
+            try {
+                return Promise.resolve(sink.flush({ signal }));
+            } catch (error) {
+                return Promise.reject(error);
+            }
+        });
+    await Promise.allSettled(flushes);
+}
+
+function setSpanContextProvider(provider) {
+    state().spanContextProvider = typeof provider === 'function' ? provider : null;
+}
+
+function getSpanContextProvider() {
+    return state().spanContextProvider;
+}
+
+function getSpanContext() {
+    const provider = state().spanContextProvider;
+    if (!provider) return null;
+    try {
+        const ctx = provider();
+        if (ctx && typeof ctx.traceId === 'string' && typeof ctx.spanId === 'string') {
+            return ctx;
+        }
+    } catch {
+        // A broken provider must not break logging.
+    }
+    return null;
+}
+
+// Off in production, so a warm container never grows this list.
+function recordViolation(violation) {
+    const s = state();
+    if (s.trackViolations) s.violations.push(violation);
+}
+
+function takeViolationsForTests() {
+    return state().violations.splice(0);
+}
+
+function resetLoggerForTests({ level, sinks, trackViolations } = {}) {
+    const s = state();
+    s.config = null;
+    s.levelOverride = parseLevel(level);
+    s.sinks = Array.isArray(sinks) ? [...sinks] : [require('./sinks').createStdoutSink()];
+    s.spanContextProvider = null;
+    s.warned.clear();
+    s.violations.length = 0;
+    s.inLog = false;
+    if (typeof trackViolations === 'boolean') s.trackViolations = trackViolations;
+}
+
+module.exports = {
+    state,
+    getConfig,
+    takeConfigWarnings,
+    getSinks,
+    setSinks,
+    hasFlushableSinks,
+    flushSinks,
+    setSpanContextProvider,
+    getSpanContextProvider,
+    getSpanContext,
+    recordViolation,
+    takeViolationsForTests,
+    resetLoggerForTests,
+};

package/logs/logger.js

@@ -1,65 +1,155 @@
-const util = require('util');
+const { LEVELS, parseLevel } = require('./levels');
+const { getLoggerScope } = require('./context');
+const runtime = require('./logger-runtime');
+const { buildRecord, DEFAULT_LOGGER_NAME } = require('./record');
 
-// Except in some outlier circumstances, for example steam or event error handlers, this should be the only place that calls `console.*`.  That way, this file can be modified to log everything properly on a variety of platforms because all the logging code is here in one place.
-/* eslint-disable no-console */
+const LOGGER_OWN_NAME = 'frigg.logger';
 
-const logs = [];
-let flushCalled = false;
-
-function debug(...messages) {
-    if (messages.length) {
-        const date = new Date();
-        const text = util.format.apply(null, messages);
+function copyBindings(bindings) {
+    const copy = {};
+    if (!bindings || typeof bindings !== 'object') return copy;
+    for (const key of Object.keys(bindings)) {
+        try {
+            copy[key] = bindings[key];
+        } catch {
+            // A throwing getter drops only that binding.
+        }
+    }
+    return copy;
+}
 
-        if (process.env.DEBUG_VERBOSE === '1') {
-            console.debug(date, text);
-        } else {
-            logs.push({ date, text });
+function evaluateBindings(sources) {
+    const merged = {};
+    for (const source of sources) {
+        let value = source;
+        if (typeof source === 'function') {
+            try {
+                value = source();
+            } catch {
+                continue;
+            }
         }
+        Object.assign(merged, copyBindings(value));
     }
+    return merged;
+}
+
+function isFriggViolation(record) {
+    return (
+        record.logger.startsWith('frigg.') &&
+        LEVELS[record.level] >= LEVELS.WARN &&
+        !record.eventName
+    );
 }
 
-function initDebugLog(...initMessages) {
-    flushCalled = false;
+class Logger {
+    constructor(name, bindingSources = []) {
+        this.name = name;
+        this._bindingSources = bindingSources;
+    }
 
-    // Hacky but fast way to empty an array.
-    logs.length = 0;
+    trace(message, fields) {
+        this._log('TRACE', message, fields);
+    }
 
-    // Log initial event
-    debug(...initMessages);
-}
+    debug(message, fields) {
+        this._log('DEBUG', message, fields);
+    }
+
+    info(message, fields) {
+        this._log('INFO', message, fields);
+    }
+
+    warn(message, fields) {
+        this._log('WARN', message, fields);
+    }
+
+    error(message, fields) {
+        this._log('ERROR', message, fields);
+    }
+
+    fatal(message, fields) {
+        this._log('FATAL', message, fields);
+    }
+
+    child(bindings) {
+        const source = typeof bindings === 'function' ? bindings : copyBindings(bindings);
+        return new Logger(this.name, [...this._bindingSources, source]);
+    }
 
-function flushDebugLog(error) {
-    if (flushCalled) {
-        console.debug(
-            'Another error was encountered while handling the same request or event!  All debug messages are included again in this output as well.'
-        );
+    isLevelEnabled(level) {
+        try {
+            const name = parseLevel(level);
+            return name !== null && LEVELS[name] >= runtime.getConfig().threshold;
+        } catch {
+            return false;
+        }
     }
 
-    flushCalled = true;
+    _log(level, message, fields) {
+        const state = runtime.state();
+        if (state.inLog) return;
+        try {
+            const config = runtime.getConfig();
+            emitConfigWarnings();
+            if (LEVELS[level] < config.threshold) return;
+            // Set before fields, bindings and sinks run: any of them may log.
+            state.inLog = true;
 
-    // Output unless in verbose mode.  In verbose mode, these will already have been output so we don't want to output the messages twice.
-    if (process.env.DEBUG_VERBOSE !== '1') {
-        if (logs?.length > 0) {
-            for (const { date, text } of logs) {
-                console.debug(date, text);
+            const record = buildRecord({
+                level,
+                logger: this.name,
+                message,
+                fields,
+                bindings: evaluateBindings(this._bindingSources),
+                scope: getLoggerScope(),
+                spanContext: runtime.getSpanContext(),
+                resource: { appName: config.appName, stage: config.stage },
+            });
+            if (isFriggViolation(record)) {
+                runtime.recordViolation({
+                    logger: record.logger,
+                    level: record.level,
+                    message: record.message,
+                });
             }
+            writeToSinks(record);
+        } catch {
+            // The logger never throws.
+        } finally {
+            state.inLog = false;
         }
     }
+}
 
-    if (!error) {
-        error = new Error('flushDebugLog called with empty error');
+function writeToSinks(record) {
+    for (const sink of runtime.getSinks()) {
+        try {
+            sink.write(record);
+        } catch {
+            // One failing sink must not stop the others.
+        }
     }
+}
 
-    console.error(error);
+function emitConfigWarnings() {
+    const warnings = runtime.takeConfigWarnings();
+    if (!warnings.length) return;
+    const logger = getLogger(LOGGER_OWN_NAME);
+    for (const warning of warnings) {
+        logger.warn(warning.message, {
+            ...warning.fields,
+            eventName: warning.eventName,
+        });
+    }
+}
 
-    let { cause: parentError } = error;
+const loggers = new Map();
 
-    while (parentError) {
-        console.error('(Caused By)-------------------------');
-        console.error(parentError);
-        parentError = parentError.cause;
-    }
+function getLogger(name) {
+    const key = typeof name === 'string' && name ? name : DEFAULT_LOGGER_NAME;
+    if (!loggers.has(key)) loggers.set(key, new Logger(key));
+    return loggers.get(key);
 }
 
-module.exports = { debug, initDebugLog, flushDebugLog };
+module.exports = { Logger, getLogger };

package/logs/record.js

@@ -0,0 +1,199 @@
+const { LEVELS } = require('./levels');
+const { serializeValue, serializeError } = require('./serialize');
+
+const MAX_RECORD_BYTES = 16 * 1024;
+const REQUIRED_KEYS = ['timestamp', 'level', 'message', 'logger'];
+const RESOURCE_KEYS = ['appName', 'stage'];
+const TRACE_KEYS = ['trace_id', 'span_id', 'trace_flags'];
+const DROPPED_KEYS_FIELD = 'droppedKeys';
+const OWNED_KEYS = new Set([
+    ...REQUIRED_KEYS,
+    ...RESOURCE_KEYS,
+    ...TRACE_KEYS,
+    DROPPED_KEYS_FIELD,
+]);
+const RESERVED_KEYS = new Set([
+    'tenantId',
+    'type',
+    'time',
+    'record',
+    'errorType',
+    'errorMessage',
+    'stackTrace',
+    'service',
+    'env',
+    'host',
+    'source',
+    'status',
+    'severity',
+]);
+const PAYLOAD_KEYS = new Set(['body', 'rawBody', 'payload', 'response']);
+const DEFAULT_LOGGER_NAME = 'frigg.unknown';
+
+function isError(value) {
+    return (
+        value instanceof Error ||
+        Object.prototype.toString.call(value) === '[object Error]'
+    );
+}
+
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        for (const key of Object.keys(value)) deepFreeze(value[key]);
+        Object.freeze(value);
+    }
+    return value;
+}
+
+function readFields(source) {
+    const result = {};
+    if (!source || typeof source !== 'object') return result;
+    let keys;
+    try {
+        keys = Object.keys(source);
+    } catch {
+        return result;
+    }
+    for (const key of keys) {
+        try {
+            result[key] = source[key];
+        } catch {
+            result[key] = '[Getter threw]';
+        }
+    }
+    return result;
+}
+
+function buildMessage(message, callSite) {
+    if (typeof message === 'string') {
+        return serializeValue(message);
+    }
+    if (message === undefined || message === null) return '';
+    if (isError(message)) {
+        const error = serializeError(message);
+        if (callSite.error === undefined) callSite.error = message;
+        return typeof error?.message === 'string' ? error.message : '';
+    }
+    if (callSite.value === undefined) callSite.value = message;
+    return '[non-string message]';
+}
+
+function traceFields(spanContext) {
+    if (
+        !spanContext ||
+        typeof spanContext.traceId !== 'string' ||
+        typeof spanContext.spanId !== 'string'
+    ) {
+        return {};
+    }
+    const flags = Number(spanContext.traceFlags) || 0;
+    return {
+        trace_id: spanContext.traceId,
+        span_id: spanContext.spanId,
+        trace_flags: (flags & 0xff).toString(16).padStart(2, '0'),
+    };
+}
+
+function byteLength(record) {
+    return Buffer.byteLength(JSON.stringify(record));
+}
+
+function buildRecord({
+    level,
+    logger,
+    message,
+    fields,
+    bindings,
+    scope,
+    spanContext,
+    resource = {},
+    now = new Date(),
+} = {}) {
+    const dropPayloads = LEVELS[level] >= LEVELS.INFO;
+    // log.error('msg', err): own props of an Error (axios config, request) must not become fields.
+    const callSite = readFields(isError(fields) ? { error: fields } : fields);
+    const record = {
+        timestamp: now.toISOString(),
+        level,
+        message: buildMessage(message, callSite),
+        logger: typeof logger === 'string' && logger ? logger : DEFAULT_LOGGER_NAME,
+    };
+    for (const key of RESOURCE_KEYS) {
+        if (typeof resource[key] === 'string' && resource[key]) {
+            record[key] = resource[key];
+        }
+    }
+    Object.assign(record, traceFields(spanContext));
+
+    const dropped = new Set();
+    const callSiteKeys = [];
+    const place = (source, isCallSite) => {
+        const accepted = {};
+        for (const [key, value] of Object.entries(source)) {
+            if (value === undefined || value === null) continue;
+            if (
+                OWNED_KEYS.has(key) ||
+                RESERVED_KEYS.has(key) ||
+                (dropPayloads && PAYLOAD_KEYS.has(key)) ||
+                Object.prototype.hasOwnProperty.call(record, key)
+            ) {
+                dropped.add(key);
+                continue;
+            }
+            accepted[key] = value;
+        }
+        // One pass over the object, so key rules (denied keys, digests,
+        // headers, OAuth shapes) apply to top-level fields too.
+        const safe = serializeValue(accepted);
+        for (const key of Object.keys(accepted)) {
+            const value =
+                key === 'error' ? serializeError(accepted[key]) : safe?.[key];
+            if (value === undefined || value === null) continue;
+            record[key] = value;
+            if (isCallSite) callSiteKeys.push(key);
+        }
+    };
+    place(readFields(scope), false);
+    place(readFields(bindings), false);
+    place(callSite, true);
+
+    const measure = () => {
+        delete record[DROPPED_KEYS_FIELD];
+        if (dropped.size) record[DROPPED_KEYS_FIELD] = [...dropped];
+        return byteLength(record);
+    };
+
+    if (measure() > MAX_RECORD_BYTES) {
+        const bySize = callSiteKeys
+            .filter((key) => key !== 'error')
+            .map((key) => [key, Buffer.byteLength(JSON.stringify(record[key]))])
+            .sort((a, b) => b[1] - a[1]);
+        for (const [key] of bySize) {
+            delete record[key];
+            dropped.add(key);
+            if (measure() <= MAX_RECORD_BYTES) break;
+        }
+    }
+    for (const part of ['stack', 'cause']) {
+        if (
+            record.error &&
+            typeof record.error === 'object' &&
+            record.error[part] !== undefined &&
+            measure() > MAX_RECORD_BYTES
+        ) {
+            const { [part]: _removed, ...rest } = record.error;
+            record.error = rest;
+        }
+    }
+    measure();
+
+    return deepFreeze(record);
+}
+
+module.exports = {
+    buildRecord,
+    MAX_RECORD_BYTES,
+    RESERVED_KEYS,
+    PAYLOAD_KEYS,
+    DEFAULT_LOGGER_NAME,
+};