@takeshape/logger 11.143.2 → 11.154.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/logger",
-  "version": "11.143.2",
+  "version": "11.154.1",
   "description": "Logging utility.",
   "homepage": "https://www.takeshape.io",
   "repository": {

package/dist/constants.d.ts

@@ -1,4 +0,0 @@
-export declare const logProviders: readonly ["CLOUDWATCH", "CLOUDWATCH_LAMBDA", "CONSOLE"];
-export declare const logLevels: readonly ["DEBUG", "INFO", "WARN", "ERROR"];
-export declare const defaultLogProvider: "CLOUDWATCH";
-export declare const defaultLogLevel: "INFO";

package/dist/constants.js

@@ -1,4 +0,0 @@
-export const logProviders = ['CLOUDWATCH', 'CLOUDWATCH_LAMBDA', 'CONSOLE'];
-export const logLevels = ['DEBUG', 'INFO', 'WARN', 'ERROR'];
-export const defaultLogProvider = 'CLOUDWATCH';
-export const defaultLogLevel = 'INFO';

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export * from './constants.ts';
-export * from './logger.ts';
-export * from './types.ts';

package/dist/index.js

@@ -1,3 +0,0 @@
-export * from "./constants.js";
-export * from "./logger.js";
-export * from "./types.js";

package/dist/logger.d.ts

@@ -1,25 +0,0 @@
-import type Sentry from '@sentry/core';
-import type { LogContext, Logger, LogProvider } from './types.ts';
-type JsonLog = {
-    [key: string]: unknown;
-    timestamp: string;
-    level: string;
-    message: string;
-    requestId?: string;
-    errorType?: string;
-    errorMessage?: string;
-    stackTrace?: string;
-};
-export declare function formatLogEntry(jsonLog: JsonLog, { prefixMessage }?: {
-    prefixMessage?: boolean;
-}): string;
-export declare function shouldReportToSentry(error: Error): boolean;
-export declare function getLogLevelScore(logLevel: string): number;
-type LoggerOptions = {
-    provider: LogProvider;
-    level: string;
-    sentryClient?: Pick<Sentry.Client, 'captureException' | 'captureMessage'>;
-    messageOnly?: boolean;
-};
-export declare function createLogger({ level, ...options }: LoggerOptions, logContext?: LogContext): Logger;
-export {};

package/dist/logger.js

@@ -1,263 +0,0 @@
-import cloneDeep from 'lodash/cloneDeep.js';
-import merge from 'lodash/merge.js';
-import { logLevels } from "./constants.js";
-const noop = () => {
-    // Empty
-};
-function getFargateEmf(now, metadata) {
-    return {
-        _aws: {
-            Timestamp: now,
-            CloudWatchMetrics: [
-                {
-                    Namespace: 'fargate-function-metrics',
-                    Dimensions: [['serviceName', 'taskRevision']],
-                    Metrics: [
-                        {
-                            Name: 'time',
-                            Unit: 'Milliseconds',
-                            StorageResolution: 60
-                        }
-                    ]
-                }
-            ]
-        },
-        serviceName: metadata.context?.platform?.fargate?.service,
-        taskRevision: metadata.context?.platform?.fargate?.task_revision,
-        time: metadata.event?.duration
-    };
-}
-function getLambdaEmf(now, metadata) {
-    return {
-        _aws: {
-            Timestamp: now,
-            CloudWatchMetrics: [
-                {
-                    Namespace: 'lambda-function-metrics',
-                    Dimensions: [['functionVersion']],
-                    Metrics: [
-                        {
-                            Name: 'time',
-                            Unit: 'Milliseconds',
-                            StorageResolution: 60
-                        }
-                    ]
-                }
-            ]
-        },
-        functionVersion: '$LATEST',
-        time: metadata.event?.duration
-    };
-}
-/**
- * Create a structured JSON log statement, compatible with the Lambda / Cloudwatch format.
- *
- * @link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-logging.html#nodejs-logging-advanced-JSON
- */
-function getJsonLog({ level, message, metadata, requestId, error, messageOnly }, emfFn) {
-    const now = metadata.timestamp ? new Date(metadata.timestamp).valueOf() : Date.now();
-    // https://docs.aws.amazon.com/lambda/latest/dg/nodejs-logging.html#nodejs-logging-advanced-level
-    let jsonLog = {
-        // Set message first, so we can read it without expanding the entry
-        message,
-        level,
-        timestamp: new Date(now).toISOString(),
-        requestId,
-        ...(!messageOnly ? metadata : undefined)
-    };
-    if (error) {
-        jsonLog = {
-            ...jsonLog,
-            errorType: error.name,
-            errorMessage: error.message,
-            stackTrace: error.stack
-        };
-    }
-    if (emfFn && metadata.event?.duration) {
-        // https://docs.aws.amazon.com/lambda/latest/dg/nodejs-logging.html#nodejs-logging-advanced-emf
-        jsonLog = {
-            ...jsonLog,
-            ...emfFn(now, metadata)
-        };
-    }
-    return jsonLog;
-}
-export function formatLogEntry(jsonLog, { prefixMessage } = {}) {
-    if (prefixMessage) {
-        // \r adds a line break in the message, \n creates a new log entry. This works with Lambda and the jsonLog will be parsed.
-        return `${jsonLog.message} \r${JSON.stringify(jsonLog)}\n`;
-    }
-    // In Fargate, only pure JSON log objects get parsed
-    return `${JSON.stringify(jsonLog)}\n`;
-}
-function isFieldNode(node) {
-    return node.kind === 'Field';
-}
-function isGraphQLError(error) {
-    return error.name === 'GraphQLError';
-}
-function getGraphQLErrorExtras(error) {
-    const { path, nodes } = error;
-    const fieldName = nodes?.find(isFieldNode)?.name.value;
-    return {
-        path,
-        fieldName
-    };
-}
-function getAggregateErrorExtras(error) {
-    const errors = error.errors.map((e) => {
-        if (Array.isArray(e)) {
-            return e.join(', ');
-        }
-        if (typeof e === 'object') {
-            return e?.message;
-        }
-        return e;
-    });
-    return {
-        errors
-    };
-}
-function getSentryExtras(error) {
-    let extras = {};
-    if (isGraphQLError(error)) {
-        extras = {
-            ...extras,
-            ...getGraphQLErrorExtras(error)
-        };
-        if (error.originalError) {
-            extras = {
-                ...extras,
-                ...getSentryExtras(error.originalError)
-            };
-        }
-    }
-    if (error instanceof AggregateError) {
-        extras = {
-            ...extras,
-            ...getAggregateErrorExtras(error)
-        };
-    }
-    return extras;
-}
-export function shouldReportToSentry(error) {
-    if (isGraphQLError(error)) {
-        if (error.originalError) {
-            return shouldReportToSentry(error.originalError);
-        }
-        return false;
-    }
-    if ('reportToSentry' in error) {
-        return Boolean(error.reportToSentry);
-    }
-    return true;
-}
-function decorateLogFn({ provider, level, sentryClient, messageOnly }, entry) {
-    return (messageOrError, logMetadata) => {
-        let metadata = logMetadata;
-        let message;
-        let error;
-        if (messageOrError instanceof Error) {
-            error = messageOrError;
-            message = error.message;
-        }
-        else {
-            error = metadata?.error;
-            message = messageOrError;
-        }
-        if (metadata) {
-            const { error, ...rest } = metadata;
-            // Merge passed context with the base context, and exclude any message, and the error
-            metadata = merge({}, entry, rest);
-        }
-        else {
-            metadata = entry;
-        }
-        if (sentryClient && (level === 'ERROR' || level === 'WARN')) {
-            const sentryLevel = level === 'WARN' ? 'warning' : 'error';
-            const sentryHint = {
-                captureContext(scope) {
-                    scope.setTransactionName(message);
-                    scope.setLevel(sentryLevel);
-                    scope.addBreadcrumb({
-                        type: 'error',
-                        message,
-                        level: sentryLevel
-                    });
-                    if (entry.context?.user?.id) {
-                        scope.setUser(entry.context.user);
-                    }
-                    const project = entry.context?.custom?.project;
-                    if (project?.id) {
-                        scope.setTag('projectId', project.id);
-                    }
-                    if (project?.schemaId) {
-                        scope.setTag('schemaId', project.schemaId);
-                    }
-                    if (project?.schemaHash) {
-                        scope.setTag('schemaHash', project.schemaHash);
-                    }
-                    if (error) {
-                        scope.setExtras(getSentryExtras(error));
-                    }
-                    return scope;
-                }
-            };
-            if (error) {
-                if (shouldReportToSentry(error)) {
-                    sentryClient.captureException(error, sentryHint);
-                }
-            }
-            else {
-                sentryClient.captureMessage(message, sentryLevel, sentryHint);
-            }
-        }
-        if (provider === 'CONSOLE') {
-            // biome-ignore lint/suspicious/noConsole: allowed
-            const consoleMethod = console[level.toLowerCase()];
-            if (!messageOnly) {
-                consoleMethod(...[message, error, metadata].filter((x) => x));
-            }
-            else {
-                consoleMethod(...[message, error].filter((x) => x));
-            }
-            return;
-        }
-        const jsonLog = getJsonLog({
-            level,
-            message,
-            metadata,
-            error,
-            requestId: metadata?.context?.http?.request_id,
-            messageOnly
-        }, provider === 'CLOUDWATCH_LAMBDA' ? getLambdaEmf : getFargateEmf);
-        process.stdout.write(formatLogEntry(jsonLog, {
-            prefixMessage: provider === 'CLOUDWATCH_LAMBDA'
-        }));
-    };
-}
-export function getLogLevelScore(logLevel) {
-    const logLevelUpper = logLevel.toUpperCase();
-    return logLevels.indexOf((logLevelUpper && logLevels.includes(logLevelUpper) ? logLevelUpper : 'INFO'));
-}
-export function createLogger({ level, ...options }, logContext = {}) {
-    const score = getLogLevelScore(level);
-    const context = cloneDeep(logContext);
-    const event = {};
-    return {
-        debug: score > logLevels.indexOf('DEBUG') ? noop : decorateLogFn({ level: 'DEBUG', ...options }, { context, event }),
-        info: score > logLevels.indexOf('INFO') ? noop : decorateLogFn({ level: 'INFO', ...options }, { context, event }),
-        warn: score > logLevels.indexOf('WARN') ? noop : decorateLogFn({ level: 'WARN', ...options }, { context, event }),
-        error: score > logLevels.indexOf('ERROR') ? noop : decorateLogFn({ level: 'ERROR', ...options }, { context, event }),
-        updateContext(update) {
-            // mutates context
-            merge(context, update);
-        },
-        context,
-        updateEvent(update) {
-            // mutates event
-            merge(event, update);
-        },
-        event
-    };
-}

package/dist/types.d.ts

@@ -1,312 +0,0 @@
-import type { logLevels, logProviders } from './constants.ts';
-/**
- * The duration, in fractional milliseconds, that it took to complete this event.
- */
-export type TimeMs = number;
-/**
- * The target host of the HTTP request. This may not be the same as the real hostname of the server.
- */
-export type HttpHost = string;
-/**
- * The HTTP method for the request.
- */
-export type HttpMethod = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
-/**
- * The path of the HTTP request.
- */
-export type HttpPath = string;
-/**
- * The IP address of the computer that issued the request.
- */
-export type HttpRemoteAddr = string;
-/**
- * An ID that uniquely identifies the request and can be used to trace requests.
- */
-export type HttpRequestId = string;
-/**
- * The body of the HTTP request / response.
- */
-export type HttpBody = string;
-/**
- * The value of the Content-Length header representing the size of the request in decimal number of octets.
- */
-export type HttpContentLength = number;
-/**
- * The direction of the HTTP request and response (incoming or outgoing).
- */
-export type HttpDirection = 'incoming' | 'outgoing';
-/**
- * An encoded JSON string representing *all* HTTP headers. This is used for request inspection without the overhead of creating and indexing fields for every header.
- */
-export type HttpHeadersJson = string;
-/**
- * An object representing *select* HTTP headers that need to be searched or graphed.
- */
-export type HttpHeaders = Record<string, any>;
-/**
- * The target port of the HTTP request. This may be different than the port the server is listening on.
- */
-export type HttpPort = number;
-/**
- * The query parameters present on the URL.
- */
-export type HttpQueryString = string;
-/**
- * The HTTP request scheme.
- */
-export type HttpScheme = 'http' | 'https';
-/**
- * A short label / name for the service you are sending the request to, ex: elasticsearch
- */
-export type HttpServiceName = string;
-/**
- * The status as defined by the HTTP status codes.
- */
-export type HttpStatus = number;
-export type LogErrorBacktrace = {
-    /**
-     * Application name, if applicable. For example, erlang / elixir have multiple apps within the same umbrella project.
-     */
-    app_name?: string;
-    /**
-     * The line file path.
-     */
-    file: string;
-    /**
-     * The calling function name.
-     */
-    function: string;
-    /**
-     * The calling line number.
-     */
-    line: number;
-};
-export type LogError = {
-    /**
-     * An optional array of lines, representing the call stack, leading up to the error.
-     */
-    backtrace?: LogErrorBacktrace[];
-    /**
-     * Optional message describing the error.
-     */
-    message?: string;
-    /**
-     * A JSON encoded string representing additional metadata. This provides insight without the overhead of creating and indexing fields.
-     */
-    metadata_json?: string;
-    /**
-     * Required name of the error.
-     */
-    name: string;
-};
-export type LogContext = {
-    /**
-     * An open ended object where custom context is supplied.
-     */
-    custom?: Record<string, Record<string, any>>;
-    /**
-     * Context about the HTTP request currently being processed (if any)
-     */
-    http?: {
-        host?: HttpHost;
-        method: HttpMethod;
-        path?: HttpPath;
-        remote_addr?: HttpRemoteAddr;
-        request_id?: HttpRequestId;
-        start_at?: TimeMs;
-    };
-    /**
-     * Represents a task or job execution, typically for background tasks or jobs.
-     */
-    job?: {
-        /**
-         * The attempt number, if applicable.
-         */
-        attempt?: number;
-        /**
-         * A unique identifier for the job or task.
-         */
-        id?: string;
-        /**
-         * The name of the queue being processes, if applicable.
-         */
-        queue_name?: string;
-    };
-    /**
-     * Contextual information about the hosting platform (AWS, Google Cloud, Heroku, etc) the application is hosted.
-     */
-    platform?: {
-        [k: string]: any;
-        /**
-         * A boolean indicating if the application is running in a "live" SST environment (sst dev + live whitelist).
-         */
-        isLive?: boolean;
-        /**
-         * A boolean indicating if the application is running in a dev SST environment (sst dev).
-         */
-        isDev?: boolean;
-        /**
-         * Contextual information about the service running on the Fargate
-         */
-        fargate?: {
-            [k: string]: any;
-            /**
-             * The unique identifier for the Docker container running inside the Fargate task.
-             */
-            container_name: string;
-            /**
-             * The collection of key value pairs found in the Kubernetes Pod metadata field Labels
-             */
-            labels?: Record<string, any>;
-            /**
-             * The Fargate service in which this task is running
-             */
-            service: string;
-            /**
-             * The task revision in which this container is running.
-             */
-            task_revision: string;
-            /**
-             * The task arn in which this container is running.
-             */
-            task_arn: string;
-        };
-        /**
-         * Contextual information about the Lambda fn
-         */
-        lambda?: {
-            [k: string]: any;
-            /**
-             * Function name for the Lambda fn.
-             */
-            function_name: string;
-        };
-    };
-    /**
-     * Contextual information on the current release
-     */
-    release?: {
-        /**
-         * The git commit sha for the deploy
-         */
-        commit_hash?: string;
-        /**
-         * When the release was created, ISO8601 date time.
-         */
-        created_at?: string;
-        /**
-         * Deploy version, can be an unique string. Ex: 1.1.2 or a43fdw
-         */
-        version?: string;
-    };
-    /**
-     * Represents a user in the platform being logged. The interpretation of "user" is left to the consumer.
-     */
-    user?: {
-        /**
-         * An email address for the user. This need not be unique to the user. Note that no validation is performed on this field.
-         */
-        email?: string;
-        /**
-         * A unique identifier for the user.
-         */
-        id?: string;
-        /**
-         * Additional custom metadata you'd like to add to the user.
-         */
-        meta?: Record<string, any>;
-        /**
-         * A display name for the user.
-         */
-        name?: string;
-        /**
-         * The type of user. Used in systems where there are multiple user types. This helps to denote users in the case of polymorphism.
-         */
-        type?: string;
-    };
-};
-export type LogEvent = {
-    /**
-     * An open ended object used for custom event data. Only a single root key is allowed, this represents the event type and avoids type collisions in the context of the entire schema.
-     */
-    custom?: Record<string, Record<string, any>>;
-    /**
-     * Represents an error or exception.
-     */
-    error?: LogError;
-    /**
-     * The duration, in milliseconds, that it took to complete this event.
-     */
-    duration?: TimeMs;
-    /**
-     * Represents a HTTP request, both incoming and outgoing. Note the direction field.
-     */
-    http_request?: {
-        body?: HttpBody;
-        content_length?: HttpContentLength;
-        direction?: HttpDirection;
-        headers?: HttpHeaders;
-        headers_json?: HttpHeadersJson;
-        host?: HttpHost;
-        method: HttpMethod;
-        path?: HttpPath;
-        port?: HttpPort;
-        query_string?: HttpQueryString;
-        request_id?: HttpRequestId;
-        scheme?: HttpScheme;
-        service_name?: HttpServiceName;
-        start_time?: TimeMs;
-        path_parameters?: Record<string, string | undefined>;
-        query_parameters?: Record<string, string | string[] | undefined>;
-        route_key?: string;
-    };
-    /**
-     * Represents a HTTP response event, both outgoing and incoming. Note the direction field.
-     */
-    http_response?: {
-        body?: HttpBody;
-        content_length?: HttpContentLength;
-        direction?: HttpDirection;
-        headers?: HttpHeaders;
-        headers_json?: HttpHeadersJson;
-        request_id?: HttpRequestId;
-        service_name?: HttpServiceName;
-        status: HttpStatus;
-        end_time?: TimeMs;
-    };
-};
-export type LogEntry = {
-    /**
-     * The IOS8601 formatted datetime when the log was generated.
-     */
-    timestamp?: string | undefined;
-    /**
-     * The raw log event message, formatting stripped.
-     */
-    message?: string | undefined;
-    /**
-     * Contextual metadata about the environment the event takes place in
-     */
-    context?: LogContext | undefined;
-    /**
-     * A controlled representation of the event this log line represents.
-     */
-    event?: LogEvent | undefined;
-};
-export type LogMetadata = {
-    error?: Error;
-} & Partial<LogEntry>;
-export type LogFn = typeof console.log;
-export type LoggerFn = (message: string | Error, metadata?: LogMetadata) => void;
-export type Logger = {
-    debug: LoggerFn;
-    info: LoggerFn;
-    warn: LoggerFn;
-    error: LoggerFn;
-    updateContext: (context: LogContext) => void;
-    updateEvent: (event: LogEvent) => void;
-    context: LogContext;
-    event: LogEvent;
-};
-export type LogLevel = (typeof logLevels)[number];
-export type LogProvider = (typeof logProviders)[number];

package/dist/types.js

@@ -1 +0,0 @@
-export {};