logs-interceptor
Version:
High-performance, production-ready log interceptor for Node.js applications with Loki integration
247 lines • 7.93 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.safeStringify = safeStringify;
exports.parseLabels = parseLabels;
exports.shouldSample = shouldSample;
exports.loadConfigFromEnv = loadConfigFromEnv;
exports.mergeConfigs = mergeConfigs;
exports.validateConfig = validateConfig;
/**
* Safely stringify any value, handling circular references and non-serializable objects
*/
function safeStringify(value) {
const seen = new WeakSet();
try {
return JSON.stringify(value, function (key, val) {
if (val === null || val === undefined) {
return val;
}
if (typeof val === 'object') {
if (seen.has(val)) {
return '[Circular Reference]';
}
seen.add(val);
}
if (typeof val === 'function') {
return `[Function: ${val.name || 'anonymous'}]`;
}
if (typeof val === 'symbol') {
return `[Symbol: ${val.toString()}]`;
}
if (val instanceof Error) {
return {
name: val.name,
message: val.message,
stack: val.stack,
};
}
if (val instanceof Date) {
return val.toISOString();
}
if (val instanceof RegExp) {
return val.toString();
}
return val;
}, 2);
}
catch (error) {
return `[Unserializable: ${error instanceof Error ? error.message : 'Unknown error'}]`;
}
}
/**
* Parse labels from environment variable string format
* Format: "key1=value1,key2=value2"
*/
function parseLabels(labelsString) {
const labels = {};
if (!labelsString) {
return labels;
}
try {
const pairs = labelsString.split(',');
for (const pair of pairs) {
const [key, ...valueParts] = pair.split('=');
if (key && valueParts.length > 0) {
labels[key.trim()] = valueParts.join('=').trim();
}
}
}
catch (error) {
console.warn('Failed to parse labels from environment:', error);
}
return labels;
}
/**
* Determine if a log should be sampled based on sampling rate
*/
function shouldSample(rate) {
if (rate >= 1.0)
return true;
if (rate <= 0.0)
return false;
return Math.random() < rate;
}
/**
* Load configuration from environment variables
*/
function loadConfigFromEnv() {
const env = process.env;
const config = {};
// Transport configuration
if (env.LOGS_INTERCEPTOR_URL) {
if (!config.transport)
config.transport = {};
config.transport.url = env.LOGS_INTERCEPTOR_URL;
}
if (env.LOGS_INTERCEPTOR_TENANT_ID) {
if (!config.transport)
config.transport = {};
config.transport.tenantId = env.LOGS_INTERCEPTOR_TENANT_ID;
}
if (env.LOGS_INTERCEPTOR_AUTH_TOKEN) {
if (!config.transport)
config.transport = {};
config.transport.authToken = env.LOGS_INTERCEPTOR_AUTH_TOKEN;
}
// Application metadata
if (env.LOGS_INTERCEPTOR_APP_NAME) {
config.appName = env.LOGS_INTERCEPTOR_APP_NAME;
}
if (env.LOGS_INTERCEPTOR_ENVIRONMENT) {
config.environment = env.LOGS_INTERCEPTOR_ENVIRONMENT;
}
if (env.LOGS_INTERCEPTOR_VERSION) {
config.version = env.LOGS_INTERCEPTOR_VERSION;
}
// Labels
if (env.LOGS_INTERCEPTOR_LABELS) {
config.labels = parseLabels(env.LOGS_INTERCEPTOR_LABELS);
}
// Buffer configuration
if (env.LOGS_INTERCEPTOR_BUFFER_SIZE) {
const bufferSize = parseInt(env.LOGS_INTERCEPTOR_BUFFER_SIZE, 10);
if (!isNaN(bufferSize) && bufferSize > 0) {
config.buffer = {
...config.buffer,
maxSize: bufferSize,
};
}
}
if (env.LOGS_INTERCEPTOR_FLUSH_INTERVAL) {
const flushInterval = parseInt(env.LOGS_INTERCEPTOR_FLUSH_INTERVAL, 10);
if (!isNaN(flushInterval) && flushInterval > 0) {
config.buffer = {
...config.buffer,
flushInterval,
};
}
}
// Filtering
if (env.LOGS_INTERCEPTOR_LOG_LEVEL) {
const levels = env.LOGS_INTERCEPTOR_LOG_LEVEL.split(',')
.map(level => level.trim().toLowerCase())
.filter(level => ['debug', 'info', 'warn', 'error', 'fatal'].includes(level));
if (levels.length > 0) {
config.filter = {
...config.filter,
levels: levels,
};
}
}
if (env.LOGS_INTERCEPTOR_SAMPLING_RATE) {
const samplingRate = parseFloat(env.LOGS_INTERCEPTOR_SAMPLING_RATE);
if (!isNaN(samplingRate) && samplingRate >= 0 && samplingRate <= 1) {
config.filter = {
...config.filter,
samplingRate,
};
}
}
// Feature flags
if (env.LOGS_INTERCEPTOR_DEBUG) {
config.debug = env.LOGS_INTERCEPTOR_DEBUG.toLowerCase() === 'true';
}
if (env.LOGS_INTERCEPTOR_ENABLED) {
const enabled = env.LOGS_INTERCEPTOR_ENABLED.toLowerCase() === 'true';
if (!enabled) {
// Return a minimal config that effectively disables logging
return {
filter: {
levels: [],
},
};
}
}
return config;
}
/**
* Merge configurations with precedence: user config > env config > defaults
*/
function mergeConfigs(userConfig, envConfig) {
const merged = {
...envConfig,
...userConfig,
};
// Handle transport merge carefully
if (envConfig.transport || userConfig.transport) {
merged.transport = {
...envConfig.transport,
...userConfig.transport,
};
}
// Handle other nested objects
if (envConfig.buffer || userConfig.buffer) {
merged.buffer = { ...envConfig.buffer, ...userConfig.buffer };
}
if (envConfig.filter || userConfig.filter) {
merged.filter = { ...envConfig.filter, ...userConfig.filter };
}
if (envConfig.labels || userConfig.labels) {
merged.labels = { ...envConfig.labels, ...userConfig.labels };
}
if (envConfig.dynamicLabels || userConfig.dynamicLabels) {
merged.dynamicLabels = { ...envConfig.dynamicLabels, ...userConfig.dynamicLabels };
}
return merged;
}
/**
* Validate that required configuration is present
*/
function validateConfig(config) {
const errors = [];
if (!config.transport?.url) {
errors.push('Transport URL is required (LOGS_INTERCEPTOR_URL)');
}
if (!config.transport?.tenantId) {
errors.push('Tenant ID is required (LOGS_INTERCEPTOR_TENANT_ID)');
}
if (!config.appName) {
errors.push('App name is required (LOGS_INTERCEPTOR_APP_NAME)');
}
// Validate URL format
if (config.transport?.url) {
try {
new URL(config.transport.url);
}
catch {
errors.push('Transport URL must be a valid URL');
}
}
// Validate buffer size
if (config.buffer?.maxSize !== undefined && config.buffer.maxSize <= 0) {
errors.push('Buffer max size must be greater than 0');
}
// Validate flush interval
if (config.buffer?.flushInterval !== undefined && config.buffer.flushInterval <= 0) {
errors.push('Flush interval must be greater than 0');
}
// Validate sampling rate
if (config.filter?.samplingRate !== undefined) {
const rate = config.filter.samplingRate;
if (rate < 0 || rate > 1) {
errors.push('Sampling rate must be between 0 and 1');
}
}
return errors;
}
//# sourceMappingURL=utils.js.map