genesis-ai-cli 13.9.0 → 13.10.0

package/dist/src/observability/alerting.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Alerting System
+ *
+ * Send alerts to various channels (Slack, PagerDuty, etc.)
+ * Features:
+ * - Multiple channel support
+ * - Alert severity levels
+ * - Rate limiting to prevent alert storms
+ * - Alert aggregation
+ * - Retry with backoff
+ */
+export type AlertSeverity = 'info' | 'warning' | 'error' | 'critical';
+export type AlertChannel = 'slack' | 'pagerduty' | 'webhook' | 'console';
+export interface Alert {
+    id: string;
+    title: string;
+    message: string;
+    severity: AlertSeverity;
+    source: string;
+    timestamp: number;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+export interface ChannelConfig {
+    type: AlertChannel;
+    enabled: boolean;
+    minSeverity: AlertSeverity;
+    config: SlackConfig | PagerDutyConfig | WebhookConfig | Record<string, unknown>;
+}
+export interface SlackConfig {
+    webhookUrl: string;
+    channel?: string;
+    username?: string;
+    iconEmoji?: string;
+}
+export interface PagerDutyConfig {
+    routingKey: string;
+    apiUrl?: string;
+}
+export interface WebhookConfig {
+    url: string;
+    method?: 'POST' | 'PUT';
+    headers?: Record<string, string>;
+}
+export interface AlerterConfig {
+    channels: ChannelConfig[];
+    rateLimitPerMinute: number;
+    aggregationWindowMs: number;
+    defaultSource: string;
+    enabled: boolean;
+}
+/**
+ * Alerter class for sending alerts
+ */
+export declare class Alerter {
+    private config;
+    private alertCounts;
+    private pendingAlerts;
+    private aggregationTimer;
+    constructor(config?: Partial<AlerterConfig>);
+    /**
+     * Send an alert
+     */
+    alert(alert: Omit<Alert, 'id' | 'timestamp'>): Promise<boolean>;
+    /**
+     * Send info alert
+     */
+    info(title: string, message: string, options?: Partial<Alert>): Promise<boolean>;
+    /**
+     * Send warning alert
+     */
+    warning(title: string, message: string, options?: Partial<Alert>): Promise<boolean>;
+    /**
+     * Send error alert
+     */
+    error(title: string, error: Error, options?: Partial<Alert>): Promise<boolean>;
+    /**
+     * Send critical alert
+     */
+    critical(title: string, message: string, options?: Partial<Alert>): Promise<boolean>;
+    /**
+     * Flush pending alerts
+     */
+    flush(): Promise<void>;
+    /**
+     * Stop alerter
+     */
+    stop(): void;
+    /**
+     * Add a channel
+     */
+    addChannel(channel: ChannelConfig): void;
+    /**
+     * Get stats
+     */
+    getStats(): {
+        pendingAlerts: number;
+        channelCount: number;
+        rateLimitInfo: Map<string, {
+            count: number;
+            windowStart: number;
+        }>;
+    };
+    private sendAlert;
+    private sendToSlack;
+    private sendToPagerDuty;
+    private sendToWebhook;
+    private sendToConsole;
+    private checkRateLimit;
+    private getAggregationKey;
+    private aggregateAlerts;
+    private startAggregationTimer;
+    private generateAlertId;
+}
+/**
+ * Get global alerter
+ */
+export declare function getAlerter(config?: Partial<AlerterConfig>): Alerter;
+/**
+ * Reset global alerter
+ */
+export declare function resetAlerter(): void;
+/**
+ * Send info alert via global alerter
+ */
+export declare function alertInfo(title: string, message: string, options?: Partial<Alert>): Promise<boolean>;
+/**
+ * Send warning alert via global alerter
+ */
+export declare function alertWarning(title: string, message: string, options?: Partial<Alert>): Promise<boolean>;
+/**
+ * Send error alert via global alerter
+ */
+export declare function alertError(title: string, error: Error, options?: Partial<Alert>): Promise<boolean>;
+/**
+ * Send critical alert via global alerter
+ */
+export declare function alertCritical(title: string, message: string, options?: Partial<Alert>): Promise<boolean>;

package/dist/src/observability/alerting.js

@@ -0,0 +1,424 @@
+"use strict";
+/**
+ * Alerting System
+ *
+ * Send alerts to various channels (Slack, PagerDuty, etc.)
+ * Features:
+ * - Multiple channel support
+ * - Alert severity levels
+ * - Rate limiting to prevent alert storms
+ * - Alert aggregation
+ * - Retry with backoff
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alerter = void 0;
+exports.getAlerter = getAlerter;
+exports.resetAlerter = resetAlerter;
+exports.alertInfo = alertInfo;
+exports.alertWarning = alertWarning;
+exports.alertError = alertError;
+exports.alertCritical = alertCritical;
+const SEVERITY_LEVELS = {
+    info: 0,
+    warning: 1,
+    error: 2,
+    critical: 3,
+};
+const SEVERITY_COLORS = {
+    info: '#36a64f', // green
+    warning: '#ffcc00', // yellow
+    error: '#ff6600', // orange
+    critical: '#ff0000', // red
+};
+const SEVERITY_EMOJIS = {
+    info: 'information_source',
+    warning: 'warning',
+    error: 'x',
+    critical: 'rotating_light',
+};
+const DEFAULT_CONFIG = {
+    channels: [],
+    rateLimitPerMinute: 60,
+    aggregationWindowMs: 60000,
+    defaultSource: 'genesis',
+    enabled: true,
+};
+/**
+ * Alerter class for sending alerts
+ */
+class Alerter {
+    config;
+    alertCounts = new Map();
+    pendingAlerts = new Map();
+    aggregationTimer = null;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Start aggregation timer if needed
+        if (this.config.aggregationWindowMs > 0) {
+            this.startAggregationTimer();
+        }
+    }
+    /**
+     * Send an alert
+     */
+    async alert(alert) {
+        if (!this.config.enabled) {
+            return false;
+        }
+        const fullAlert = {
+            ...alert,
+            id: this.generateAlertId(),
+            timestamp: Date.now(),
+            source: alert.source || this.config.defaultSource,
+        };
+        // Check rate limit
+        if (!this.checkRateLimit(fullAlert)) {
+            return false;
+        }
+        // Aggregation
+        if (this.config.aggregationWindowMs > 0) {
+            const key = this.getAggregationKey(fullAlert);
+            let pending = this.pendingAlerts.get(key);
+            if (!pending) {
+                pending = [];
+                this.pendingAlerts.set(key, pending);
+            }
+            pending.push(fullAlert);
+            return true;
+        }
+        // Send immediately
+        return this.sendAlert(fullAlert);
+    }
+    /**
+     * Send info alert
+     */
+    async info(title, message, options) {
+        return this.alert({ title, message, severity: 'info', source: this.config.defaultSource, ...options });
+    }
+    /**
+     * Send warning alert
+     */
+    async warning(title, message, options) {
+        return this.alert({ title, message, severity: 'warning', source: this.config.defaultSource, ...options });
+    }
+    /**
+     * Send error alert
+     */
+    async error(title, error, options) {
+        return this.alert({
+            title,
+            message: error.message,
+            severity: 'error',
+            source: this.config.defaultSource,
+            error: {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            },
+            ...options,
+        });
+    }
+    /**
+     * Send critical alert
+     */
+    async critical(title, message, options) {
+        return this.alert({ title, message, severity: 'critical', source: this.config.defaultSource, ...options });
+    }
+    /**
+     * Flush pending alerts
+     */
+    async flush() {
+        for (const [key, alerts] of this.pendingAlerts) {
+            if (alerts.length === 0)
+                continue;
+            if (alerts.length === 1) {
+                await this.sendAlert(alerts[0]);
+            }
+            else {
+                // Aggregate
+                const aggregated = this.aggregateAlerts(alerts);
+                await this.sendAlert(aggregated);
+            }
+        }
+        this.pendingAlerts.clear();
+    }
+    /**
+     * Stop alerter
+     */
+    stop() {
+        if (this.aggregationTimer) {
+            clearInterval(this.aggregationTimer);
+            this.aggregationTimer = null;
+        }
+    }
+    /**
+     * Add a channel
+     */
+    addChannel(channel) {
+        this.config.channels.push(channel);
+    }
+    /**
+     * Get stats
+     */
+    getStats() {
+        let pendingCount = 0;
+        for (const alerts of this.pendingAlerts.values()) {
+            pendingCount += alerts.length;
+        }
+        return {
+            pendingAlerts: pendingCount,
+            channelCount: this.config.channels.length,
+            rateLimitInfo: new Map(this.alertCounts),
+        };
+    }
+    async sendAlert(alert) {
+        const promises = [];
+        for (const channel of this.config.channels) {
+            if (!channel.enabled)
+                continue;
+            if (SEVERITY_LEVELS[alert.severity] < SEVERITY_LEVELS[channel.minSeverity])
+                continue;
+            switch (channel.type) {
+                case 'slack':
+                    promises.push(this.sendToSlack(alert, channel.config));
+                    break;
+                case 'pagerduty':
+                    promises.push(this.sendToPagerDuty(alert, channel.config));
+                    break;
+                case 'webhook':
+                    promises.push(this.sendToWebhook(alert, channel.config));
+                    break;
+                case 'console':
+                    promises.push(this.sendToConsole(alert));
+                    break;
+            }
+        }
+        const results = await Promise.allSettled(promises);
+        return results.some(r => r.status === 'fulfilled' && r.value);
+    }
+    async sendToSlack(alert, config) {
+        const payload = {
+            channel: config.channel,
+            username: config.username || 'Genesis Alerts',
+            icon_emoji: config.iconEmoji || `:${SEVERITY_EMOJIS[alert.severity]}:`,
+            attachments: [{
+                    color: SEVERITY_COLORS[alert.severity],
+                    title: alert.title,
+                    text: alert.message,
+                    fields: [
+                        { title: 'Severity', value: alert.severity.toUpperCase(), short: true },
+                        { title: 'Source', value: alert.source, short: true },
+                        ...(alert.labels ? Object.entries(alert.labels).map(([k, v]) => ({
+                            title: k,
+                            value: v,
+                            short: true,
+                        })) : []),
+                    ],
+                    footer: 'Genesis Alerting',
+                    ts: Math.floor(alert.timestamp / 1000),
+                }],
+        };
+        try {
+            const response = await fetch(config.webhookUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+            });
+            return response.ok;
+        }
+        catch (error) {
+            console.error('Slack alert failed:', error);
+            return false;
+        }
+    }
+    async sendToPagerDuty(alert, config) {
+        const severityMap = {
+            info: 'info',
+            warning: 'warning',
+            error: 'error',
+            critical: 'critical',
+        };
+        const payload = {
+            routing_key: config.routingKey,
+            event_action: 'trigger',
+            dedup_key: alert.id,
+            payload: {
+                summary: `${alert.title}: ${alert.message}`,
+                source: alert.source,
+                severity: severityMap[alert.severity],
+                timestamp: new Date(alert.timestamp).toISOString(),
+                custom_details: {
+                    ...alert.labels,
+                    ...alert.annotations,
+                    ...(alert.error ? { error: alert.error } : {}),
+                },
+            },
+        };
+        try {
+            const response = await fetch(config.apiUrl || 'https://events.pagerduty.com/v2/enqueue', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+            });
+            return response.ok;
+        }
+        catch (error) {
+            console.error('PagerDuty alert failed:', error);
+            return false;
+        }
+    }
+    async sendToWebhook(alert, config) {
+        try {
+            const response = await fetch(config.url, {
+                method: config.method || 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...config.headers,
+                },
+                body: JSON.stringify(alert),
+            });
+            return response.ok;
+        }
+        catch (error) {
+            console.error('Webhook alert failed:', error);
+            return false;
+        }
+    }
+    async sendToConsole(alert) {
+        const prefix = `[ALERT:${alert.severity.toUpperCase()}]`;
+        const message = `${prefix} ${alert.title}: ${alert.message}`;
+        switch (alert.severity) {
+            case 'critical':
+            case 'error':
+                console.error(message, alert.error || '');
+                break;
+            case 'warning':
+                console.warn(message);
+                break;
+            default:
+                console.log(message);
+        }
+        return true;
+    }
+    checkRateLimit(alert) {
+        const key = `${alert.source}:${alert.severity}`;
+        const now = Date.now();
+        const windowMs = 60000; // 1 minute
+        let entry = this.alertCounts.get(key);
+        if (!entry || now - entry.windowStart > windowMs) {
+            entry = { count: 0, windowStart: now };
+            this.alertCounts.set(key, entry);
+        }
+        if (entry.count >= this.config.rateLimitPerMinute) {
+            return false;
+        }
+        entry.count++;
+        return true;
+    }
+    getAggregationKey(alert) {
+        return `${alert.source}:${alert.severity}:${alert.title}`;
+    }
+    aggregateAlerts(alerts) {
+        const first = alerts[0];
+        return {
+            ...first,
+            message: `${alerts.length} occurrences:\n${alerts.slice(0, 5).map(a => `- ${a.message}`).join('\n')}${alerts.length > 5 ? `\n... and ${alerts.length - 5} more` : ''}`,
+            annotations: {
+                ...first.annotations,
+                aggregated_count: String(alerts.length),
+            },
+        };
+    }
+    startAggregationTimer() {
+        this.aggregationTimer = setInterval(() => {
+            this.flush().catch(console.error);
+        }, this.config.aggregationWindowMs);
+        if (this.aggregationTimer.unref) {
+            this.aggregationTimer.unref();
+        }
+    }
+    generateAlertId() {
+        return `alert-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+}
+exports.Alerter = Alerter;
+// Global alerter
+let globalAlerter = null;
+/**
+ * Get global alerter
+ */
+function getAlerter(config) {
+    if (!globalAlerter) {
+        const channels = [];
+        // Add Slack if configured
+        if (process.env.SLACK_WEBHOOK_URL) {
+            channels.push({
+                type: 'slack',
+                enabled: true,
+                minSeverity: process.env.SLACK_MIN_SEVERITY || 'warning',
+                config: {
+                    webhookUrl: process.env.SLACK_WEBHOOK_URL,
+                    channel: process.env.SLACK_CHANNEL,
+                },
+            });
+        }
+        // Add PagerDuty if configured
+        if (process.env.PAGERDUTY_ROUTING_KEY) {
+            channels.push({
+                type: 'pagerduty',
+                enabled: true,
+                minSeverity: 'error',
+                config: {
+                    routingKey: process.env.PAGERDUTY_ROUTING_KEY,
+                },
+            });
+        }
+        // Add console in development
+        if (process.env.NODE_ENV === 'development' || process.env.ALERT_CONSOLE === 'true') {
+            channels.push({
+                type: 'console',
+                enabled: true,
+                minSeverity: 'info',
+                config: {},
+            });
+        }
+        globalAlerter = new Alerter({
+            ...config,
+            channels: [...channels, ...(config?.channels || [])],
+        });
+    }
+    return globalAlerter;
+}
+/**
+ * Reset global alerter
+ */
+function resetAlerter() {
+    if (globalAlerter) {
+        globalAlerter.stop();
+    }
+    globalAlerter = null;
+}
+/**
+ * Send info alert via global alerter
+ */
+async function alertInfo(title, message, options) {
+    return getAlerter().info(title, message, options);
+}
+/**
+ * Send warning alert via global alerter
+ */
+async function alertWarning(title, message, options) {
+    return getAlerter().warning(title, message, options);
+}
+/**
+ * Send error alert via global alerter
+ */
+async function alertError(title, error, options) {
+    return getAlerter().error(title, error, options);
+}
+/**
+ * Send critical alert via global alerter
+ */
+async function alertCritical(title, message, options) {
+    return getAlerter().critical(title, message, options);
+}

package/dist/src/observability/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Observability Module
+ *
+ * Production-grade observability stack:
+ * - Structured logging with pino-compatible API
+ * - Prometheus metrics collection
+ * - OpenTelemetry-compatible distributed tracing
+ * - Alerting via Slack, PagerDuty, webhooks
+ */
+export { Logger, Timer, getLogger, resetLogger, createLogger, startTimer, type LogLevel, type LogEntry, type LoggerConfig, } from './logger.js';
+export { Counter, Gauge, Histogram, Summary, MetricsRegistry, getMetricsRegistry, resetMetricsRegistry, createGenesisMetrics, type MetricType, type MetricConfig, type GenesisMetrics, } from './metrics.js';
+export { Span, Tracer, ConsoleExporter, InMemoryExporter, OTLPHttpExporter, getTracer, resetTracer, startSpan, withTrace, type SpanContext, type SpanData, type SpanKind, type SpanStatus, type SpanExporter, type TracerConfig, } from './tracer.js';
+export { Alerter, getAlerter, resetAlerter, alertInfo, alertWarning, alertError, alertCritical, type Alert, type AlertSeverity, type AlertChannel, type AlerterConfig, type SlackConfig, type PagerDutyConfig, type WebhookConfig, } from './alerting.js';
+/**
+ * Initialize full observability stack
+ */
+export interface ObservabilityConfig {
+    serviceName: string;
+    serviceVersion?: string;
+    environment?: string;
+    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    logFormat?: 'json' | 'pretty';
+    metricsPrefix?: string;
+    traceSampleRate?: number;
+    slackWebhookUrl?: string;
+}
+export declare function initObservability(config: ObservabilityConfig): {
+    logger: import('./logger.js').Logger;
+    metrics: import('./metrics.js').GenesisMetrics;
+    tracer: import('./tracer.js').Tracer;
+    alerter: import('./alerting.js').Alerter;
+};

package/dist/src/observability/index.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Observability Module
+ *
+ * Production-grade observability stack:
+ * - Structured logging with pino-compatible API
+ * - Prometheus metrics collection
+ * - OpenTelemetry-compatible distributed tracing
+ * - Alerting via Slack, PagerDuty, webhooks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alertCritical = exports.alertError = exports.alertWarning = exports.alertInfo = exports.resetAlerter = exports.getAlerter = exports.Alerter = exports.withTrace = exports.startSpan = exports.resetTracer = exports.getTracer = exports.OTLPHttpExporter = exports.InMemoryExporter = exports.ConsoleExporter = exports.Tracer = exports.Span = exports.createGenesisMetrics = exports.resetMetricsRegistry = exports.getMetricsRegistry = exports.MetricsRegistry = exports.Summary = exports.Histogram = exports.Gauge = exports.Counter = exports.startTimer = exports.createLogger = exports.resetLogger = exports.getLogger = exports.Timer = exports.Logger = void 0;
+exports.initObservability = initObservability;
+// Logger
+var logger_js_1 = require("./logger.js");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_js_1.Logger; } });
+Object.defineProperty(exports, "Timer", { enumerable: true, get: function () { return logger_js_1.Timer; } });
+Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return logger_js_1.getLogger; } });
+Object.defineProperty(exports, "resetLogger", { enumerable: true, get: function () { return logger_js_1.resetLogger; } });
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return logger_js_1.createLogger; } });
+Object.defineProperty(exports, "startTimer", { enumerable: true, get: function () { return logger_js_1.startTimer; } });
+// Metrics
+var metrics_js_1 = require("./metrics.js");
+Object.defineProperty(exports, "Counter", { enumerable: true, get: function () { return metrics_js_1.Counter; } });
+Object.defineProperty(exports, "Gauge", { enumerable: true, get: function () { return metrics_js_1.Gauge; } });
+Object.defineProperty(exports, "Histogram", { enumerable: true, get: function () { return metrics_js_1.Histogram; } });
+Object.defineProperty(exports, "Summary", { enumerable: true, get: function () { return metrics_js_1.Summary; } });
+Object.defineProperty(exports, "MetricsRegistry", { enumerable: true, get: function () { return metrics_js_1.MetricsRegistry; } });
+Object.defineProperty(exports, "getMetricsRegistry", { enumerable: true, get: function () { return metrics_js_1.getMetricsRegistry; } });
+Object.defineProperty(exports, "resetMetricsRegistry", { enumerable: true, get: function () { return metrics_js_1.resetMetricsRegistry; } });
+Object.defineProperty(exports, "createGenesisMetrics", { enumerable: true, get: function () { return metrics_js_1.createGenesisMetrics; } });
+// Tracing
+var tracer_js_1 = require("./tracer.js");
+Object.defineProperty(exports, "Span", { enumerable: true, get: function () { return tracer_js_1.Span; } });
+Object.defineProperty(exports, "Tracer", { enumerable: true, get: function () { return tracer_js_1.Tracer; } });
+Object.defineProperty(exports, "ConsoleExporter", { enumerable: true, get: function () { return tracer_js_1.ConsoleExporter; } });
+Object.defineProperty(exports, "InMemoryExporter", { enumerable: true, get: function () { return tracer_js_1.InMemoryExporter; } });
+Object.defineProperty(exports, "OTLPHttpExporter", { enumerable: true, get: function () { return tracer_js_1.OTLPHttpExporter; } });
+Object.defineProperty(exports, "getTracer", { enumerable: true, get: function () { return tracer_js_1.getTracer; } });
+Object.defineProperty(exports, "resetTracer", { enumerable: true, get: function () { return tracer_js_1.resetTracer; } });
+Object.defineProperty(exports, "startSpan", { enumerable: true, get: function () { return tracer_js_1.startSpan; } });
+Object.defineProperty(exports, "withTrace", { enumerable: true, get: function () { return tracer_js_1.withTrace; } });
+// Alerting
+var alerting_js_1 = require("./alerting.js");
+Object.defineProperty(exports, "Alerter", { enumerable: true, get: function () { return alerting_js_1.Alerter; } });
+Object.defineProperty(exports, "getAlerter", { enumerable: true, get: function () { return alerting_js_1.getAlerter; } });
+Object.defineProperty(exports, "resetAlerter", { enumerable: true, get: function () { return alerting_js_1.resetAlerter; } });
+Object.defineProperty(exports, "alertInfo", { enumerable: true, get: function () { return alerting_js_1.alertInfo; } });
+Object.defineProperty(exports, "alertWarning", { enumerable: true, get: function () { return alerting_js_1.alertWarning; } });
+Object.defineProperty(exports, "alertError", { enumerable: true, get: function () { return alerting_js_1.alertError; } });
+Object.defineProperty(exports, "alertCritical", { enumerable: true, get: function () { return alerting_js_1.alertCritical; } });
+function initObservability(config) {
+    const { Logger } = require('./logger.js');
+    const { getMetricsRegistry, createGenesisMetrics } = require('./metrics.js');
+    const { Tracer } = require('./tracer.js');
+    const { Alerter } = require('./alerting.js');
+    // Logger
+    const logger = new Logger({
+        name: config.serviceName,
+        level: config.logLevel || 'info',
+        format: config.logFormat || 'json',
+    });
+    // Metrics
+    const registry = getMetricsRegistry(config.metricsPrefix || config.serviceName);
+    const metrics = createGenesisMetrics(registry);
+    // Set build info
+    metrics.buildInfo.set(1, {
+        version: config.serviceVersion || 'unknown',
+        node_version: process.version,
+    });
+    // Tracer
+    const tracer = new Tracer({
+        serviceName: config.serviceName,
+        serviceVersion: config.serviceVersion,
+        environment: config.environment,
+        sampleRate: config.traceSampleRate ?? 1.0,
+    });
+    // Alerter
+    const channels = [];
+    if (config.slackWebhookUrl) {
+        channels.push({
+            type: 'slack',
+            enabled: true,
+            minSeverity: 'warning',
+            config: { webhookUrl: config.slackWebhookUrl },
+        });
+    }
+    const alerter = new Alerter({
+        defaultSource: config.serviceName,
+        channels,
+    });
+    return { logger, metrics, tracer, alerter };
+}