strogger/dist/utils/enrichment.js

📊 A modern structured logging library with functional programming, duck-typing, and comprehensive third-party integrations

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createDefaultEnrichmentMiddleware = exports.createEnrichmentMiddleware = exports.createLoggerInstanceEnricher = exports.createUserEnricher = exports.createEnvironmentEnricher = exports.createSessionEnricher = exports.createCorrelationEnricher = exports.generateLoggerInstanceId = exports.generateSpanId = exports.generateTraceId = exports.generateCorrelationId = void 0;
/**
 * Generates a unique correlation ID
 */
const generateCorrelationId = () => {
    return `corr_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
};
exports.generateCorrelationId = generateCorrelationId;
/**
 * Generates a trace ID (compatible with OpenTelemetry format)
 */
const generateTraceId = () => {
    return Math.random().toString(16).substr(2, 32);
};
exports.generateTraceId = generateTraceId;
/**
 * Generates a span ID
 */
const generateSpanId = () => {
    return Math.random().toString(16).substr(2, 16);
};
exports.generateSpanId = generateSpanId;
/**
 * Generates a unique logger instance ID
 */
const generateLoggerInstanceId = () => {
    const timestamp = Date.now();
    const random = Math.random().toString(36).substr(2, 9);
    const processId = process.pid || 0;
    return `logger_${timestamp}_${random}_${processId}`;
};
exports.generateLoggerInstanceId = generateLoggerInstanceId;
/**
 * Creates a correlation ID enricher
 */
const createCorrelationEnricher = () => {
    let currentCorrelationId;
    let currentTraceId;
    let currentSpanId;
    return {
        name: "correlation",
        enrich: (context) => {
            // Generate correlation ID if not present
            if (!context.correlationId) {
                currentCorrelationId = currentCorrelationId || (0, exports.generateCorrelationId)();
                context.correlationId = currentCorrelationId;
            }
            // Generate trace ID if not present
            if (!context.traceId) {
                currentTraceId = currentTraceId || (0, exports.generateTraceId)();
                context.traceId = currentTraceId;
            }
            // Generate span ID if not present
            if (!context.spanId) {
                currentSpanId = currentSpanId || (0, exports.generateSpanId)();
                context.spanId = currentSpanId;
            }
            return context;
        },
    };
};
exports.createCorrelationEnricher = createCorrelationEnricher;
/**
 * Creates a session enricher
 */
const createSessionEnricher = (sessionId) => {
    const currentSessionId = sessionId ||
        `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    return {
        name: "session",
        enrich: (context) => {
            if (!context.sessionId) {
                context.sessionId = currentSessionId;
            }
            return context;
        },
    };
};
exports.createSessionEnricher = createSessionEnricher;
/**
 * Creates an environment enricher
 */
const createEnvironmentEnricher = (serviceName, stage) => {
    return {
        name: "environment",
        enrich: (context) => {
            if (serviceName && !context.serviceName) {
                context.serviceName = serviceName;
            }
            if (stage && !context.stage) {
                context.stage = stage;
            }
            return context;
        },
    };
};
exports.createEnvironmentEnricher = createEnvironmentEnricher;
/**
 * Creates a user enricher
 */
const createUserEnricher = (userId) => {
    return {
        name: "user",
        enrich: (context) => {
            if (userId && !context.userId) {
                context.userId = userId;
            }
            return context;
        },
    };
};
exports.createUserEnricher = createUserEnricher;
/**
 * Creates a logger instance enricher
 */
const createLoggerInstanceEnricher = (instanceId) => {
    return {
        name: "loggerInstance",
        enrich: (context) => {
            if (!context.instanceId) {
                context.instanceId = instanceId;
            }
            return context;
        },
    };
};
exports.createLoggerInstanceEnricher = createLoggerInstanceEnricher;
/**
 * Creates an enrichment middleware that applies multiple enrichers
 */
const createEnrichmentMiddleware = (enrichers) => {
    return (context) => {
        return enrichers.reduce((enrichedContext, enricher) => {
            return enricher.enrich(enrichedContext);
        }, { ...context });
    };
};
exports.createEnrichmentMiddleware = createEnrichmentMiddleware;
/**
 * Creates a default enrichment middleware with common enrichers
 */
const createDefaultEnrichmentMiddleware = (serviceName, stage, sessionId, instanceId) => {
    const enrichers = [
        (0, exports.createCorrelationEnricher)(),
        (0, exports.createSessionEnricher)(sessionId),
        (0, exports.createEnvironmentEnricher)(serviceName, stage),
    ];
    // Add logger instance enricher if instanceId is provided
    if (instanceId) {
        enrichers.push((0, exports.createLoggerInstanceEnricher)(instanceId));
    }
    return (0, exports.createEnrichmentMiddleware)(enrichers);
};
exports.createDefaultEnrichmentMiddleware = createDefaultEnrichmentMiddleware;
//# sourceMappingURL=enrichment.js.map