@rawsql-ts/ztd-cli 0.19.0 → 0.20.2

package/dist/utils/telemetry.d.ts

@@ -0,0 +1,71 @@
+export type TelemetryAttributeValue = string | number | boolean | null;
+export type TelemetryAttributes = Record<string, TelemetryAttributeValue | undefined>;
+export type TelemetryStatus = 'ok' | 'error';
+export type TelemetryExportMode = 'console' | 'debug' | 'file' | 'otlp';
+export declare const TELEMETRY_DECISION_EVENT_SCHEMA: {
+    readonly 'command.selected': {
+        readonly summary: "A command path was selected and root command telemetry started.";
+        readonly allowedAttributes: readonly ["command"];
+    };
+    readonly 'command.completed': {
+        readonly summary: "A command path completed successfully.";
+        readonly allowedAttributes: readonly ["command"];
+    };
+    readonly 'model-gen.probe-mode': {
+        readonly summary: "model-gen resolved whether probing should use live PostgreSQL or ZTD fixtures.";
+        readonly allowedAttributes: readonly ["probeMode"];
+    };
+    readonly 'watch.invalid-with-dry-run': {
+        readonly summary: "ztd-config rejected an invalid watch plus dry-run option combination.";
+        readonly allowedAttributes: readonly [];
+    };
+    readonly 'command.options.resolved': {
+        readonly summary: "ztd-config resolved high-level option state that influences generation flow.";
+        readonly allowedAttributes: readonly ["dryRun", "watch", "quiet", "shouldUpdateConfig", "jsonPayload"];
+    };
+    readonly 'config.updated': {
+        readonly summary: "ztd-config persisted ddl-related project configuration changes.";
+        readonly allowedAttributes: readonly [];
+    };
+    readonly 'output.json-envelope': {
+        readonly summary: "The command emitted a machine-readable JSON envelope.";
+        readonly allowedAttributes: readonly [];
+    };
+    readonly 'watch.enabled': {
+        readonly summary: "ztd-config switched into watch mode after the initial generation.";
+        readonly allowedAttributes: readonly [];
+    };
+    readonly 'output.dry-run-diagnostic': {
+        readonly summary: "The command emitted dry-run follow-up guidance instead of writing files.";
+        readonly allowedAttributes: readonly [];
+    };
+    readonly 'output.next-steps-diagnostic': {
+        readonly summary: "The command emitted next-step guidance for interactive use.";
+        readonly allowedAttributes: readonly [];
+    };
+    readonly 'output.quiet-suppressed': {
+        readonly summary: "The command intentionally suppressed follow-up guidance because quiet mode is active.";
+        readonly allowedAttributes: readonly [];
+    };
+};
+export type TelemetryDecisionEventName = keyof typeof TELEMETRY_DECISION_EVENT_SCHEMA;
+export declare function resolveTelemetryEnabled(explicit?: boolean | string | undefined): boolean;
+export declare function resolveTelemetryExportMode(explicit?: TelemetryExportMode | string | undefined): TelemetryExportMode;
+export declare function resolveTelemetryFilePath(explicit?: string | undefined): string;
+export declare function resolveTelemetryOtlpEndpoint(explicit?: string | undefined): string;
+export declare function setTelemetryEnabled(enabled: boolean): void;
+export declare function configureTelemetry(options?: {
+    enabled?: boolean | string;
+    exportMode?: TelemetryExportMode | string;
+    filePath?: string;
+    otlpEndpoint?: string;
+}): void;
+export declare function isTelemetryEnabled(): boolean;
+export declare function getTelemetryExportMode(): TelemetryExportMode;
+export declare function flushTelemetry(): Promise<void>;
+export declare function beginCommandSpan(commandName: string, attributes?: TelemetryAttributes): void;
+export declare function finishCommandSpan(status?: TelemetryStatus): void;
+export declare function withSpan<T>(name: string, fn: () => Promise<T> | T, attributes?: TelemetryAttributes): Promise<T>;
+export declare function withSpanSync<T>(name: string, fn: () => T, attributes?: TelemetryAttributes): T;
+export declare function emitDecisionEvent(name: TelemetryDecisionEventName, attributes?: TelemetryAttributes): void;
+export declare function recordException(error: unknown, attributes?: TelemetryAttributes): void;

package/dist/utils/telemetry.js

@@ -0,0 +1,597 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEMETRY_DECISION_EVENT_SCHEMA = void 0;
+exports.resolveTelemetryEnabled = resolveTelemetryEnabled;
+exports.resolveTelemetryExportMode = resolveTelemetryExportMode;
+exports.resolveTelemetryFilePath = resolveTelemetryFilePath;
+exports.resolveTelemetryOtlpEndpoint = resolveTelemetryOtlpEndpoint;
+exports.setTelemetryEnabled = setTelemetryEnabled;
+exports.configureTelemetry = configureTelemetry;
+exports.isTelemetryEnabled = isTelemetryEnabled;
+exports.getTelemetryExportMode = getTelemetryExportMode;
+exports.flushTelemetry = flushTelemetry;
+exports.beginCommandSpan = beginCommandSpan;
+exports.finishCommandSpan = finishCommandSpan;
+exports.withSpan = withSpan;
+exports.withSpanSync = withSpanSync;
+exports.emitDecisionEvent = emitDecisionEvent;
+exports.recordException = recordException;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_perf_hooks_1 = require("node:perf_hooks");
+const node_crypto_1 = require("node:crypto");
+const TELEMETRY_ENABLED_ENV = 'ZTD_CLI_TELEMETRY';
+const TELEMETRY_EXPORT_ENV = 'ZTD_CLI_TELEMETRY_EXPORT';
+const TELEMETRY_FILE_ENV = 'ZTD_CLI_TELEMETRY_FILE';
+const TELEMETRY_OTLP_ENDPOINT_ENV = 'ZTD_CLI_TELEMETRY_OTLP_ENDPOINT';
+const DEFAULT_SCHEMA_VERSION = 1;
+const DEFAULT_OTLP_HTTP_ENDPOINT = 'http://127.0.0.1:4318/v1/traces';
+const DEFAULT_FILE_EXPORT_PATH = 'tmp/telemetry/ztd-cli.telemetry.jsonl';
+const MAX_ATTRIBUTE_STRING_LENGTH = 160;
+const REDACTED_VALUE = '[REDACTED]';
+const OTLP_STATUS_OK = 1;
+const OTLP_STATUS_ERROR = 2;
+exports.TELEMETRY_DECISION_EVENT_SCHEMA = {
+    'command.selected': {
+        summary: 'A command path was selected and root command telemetry started.',
+        allowedAttributes: ['command'],
+    },
+    'command.completed': {
+        summary: 'A command path completed successfully.',
+        allowedAttributes: ['command'],
+    },
+    'model-gen.probe-mode': {
+        summary: 'model-gen resolved whether probing should use live PostgreSQL or ZTD fixtures.',
+        allowedAttributes: ['probeMode'],
+    },
+    'watch.invalid-with-dry-run': {
+        summary: 'ztd-config rejected an invalid watch plus dry-run option combination.',
+        allowedAttributes: [],
+    },
+    'command.options.resolved': {
+        summary: 'ztd-config resolved high-level option state that influences generation flow.',
+        allowedAttributes: ['dryRun', 'watch', 'quiet', 'shouldUpdateConfig', 'jsonPayload'],
+    },
+    'config.updated': {
+        summary: 'ztd-config persisted ddl-related project configuration changes.',
+        allowedAttributes: [],
+    },
+    'output.json-envelope': {
+        summary: 'The command emitted a machine-readable JSON envelope.',
+        allowedAttributes: [],
+    },
+    'watch.enabled': {
+        summary: 'ztd-config switched into watch mode after the initial generation.',
+        allowedAttributes: [],
+    },
+    'output.dry-run-diagnostic': {
+        summary: 'The command emitted dry-run follow-up guidance instead of writing files.',
+        allowedAttributes: [],
+    },
+    'output.next-steps-diagnostic': {
+        summary: 'The command emitted next-step guidance for interactive use.',
+        allowedAttributes: [],
+    },
+    'output.quiet-suppressed': {
+        summary: 'The command intentionally suppressed follow-up guidance because quiet mode is active.',
+        allowedAttributes: [],
+    },
+};
+class NoopTelemetrySpan {
+    constructor() {
+        this.id = 'noop';
+    }
+    end() {
+        return;
+    }
+    recordException() {
+        return;
+    }
+}
+class NoopTelemetrySink {
+    startSpan() {
+        return new NoopTelemetrySpan();
+    }
+    emitDecisionEvent() {
+        return;
+    }
+    emitException() {
+        return;
+    }
+    async flush() {
+        return;
+    }
+}
+class JsonLinesTelemetrySink {
+    constructor(writeLine) {
+        this.writeLine = writeLine;
+        this.nextSpanId = 1;
+    }
+    startSpan(name, parentSpanId, attributes) {
+        const spanId = `span-${this.nextSpanId++}`;
+        const startedAt = node_perf_hooks_1.performance.now();
+        this.write({
+            kind: 'span-start',
+            spanId,
+            parentSpanId,
+            spanName: name,
+            attributes: sanitizeAttributes(attributes),
+        });
+        return {
+            id: spanId,
+            end: (status) => {
+                this.write({
+                    kind: 'span-end',
+                    spanId,
+                    parentSpanId,
+                    spanName: name,
+                    status,
+                    durationMs: roundDuration(node_perf_hooks_1.performance.now() - startedAt),
+                });
+            },
+            recordException: (error, exceptionAttributes) => {
+                this.emitException(error, spanId, exceptionAttributes);
+            },
+        };
+    }
+    emitDecisionEvent(name, spanId, attributes) {
+        const schema = exports.TELEMETRY_DECISION_EVENT_SCHEMA[name];
+        this.write({
+            kind: 'decision',
+            eventName: name,
+            spanId,
+            attributes: sanitizeAttributes(attributes, schema.allowedAttributes),
+        });
+    }
+    emitException(error, spanId, attributes) {
+        this.write({
+            kind: 'exception',
+            spanId,
+            error: normalizeError(error),
+            attributes: sanitizeAttributes(attributes),
+        });
+    }
+    async flush() {
+        return;
+    }
+    write(payload) {
+        this.writeLine(JSON.stringify(buildTelemetryEnvelope(payload)));
+    }
+}
+class DebugTelemetrySink {
+    constructor() {
+        this.nextSpanId = 1;
+    }
+    startSpan(name, parentSpanId, attributes) {
+        const spanId = `span-${this.nextSpanId++}`;
+        const startedAt = node_perf_hooks_1.performance.now();
+        this.write('span-start', name, spanId, parentSpanId, sanitizeAttributes(attributes));
+        return {
+            id: spanId,
+            end: (status) => {
+                this.write('span-end', name, spanId, parentSpanId, {
+                    status,
+                    durationMs: roundDuration(node_perf_hooks_1.performance.now() - startedAt),
+                });
+            },
+            recordException: (error, exceptionAttributes) => {
+                this.emitException(error, spanId, exceptionAttributes);
+            },
+        };
+    }
+    emitDecisionEvent(name, spanId, attributes) {
+        const schema = exports.TELEMETRY_DECISION_EVENT_SCHEMA[name];
+        this.write('decision', name, spanId, undefined, sanitizeAttributes(attributes, schema.allowedAttributes));
+    }
+    emitException(error, spanId, attributes) {
+        this.write('exception', normalizeError(error).message, spanId, undefined, sanitizeAttributes(attributes));
+    }
+    async flush() {
+        return;
+    }
+    write(kind, label, spanId, parentSpanId, data = {}) {
+        const summary = JSON.stringify(data);
+        const suffix = summary === '{}' ? '' : ` ${summary}`;
+        const parent = parentSpanId ? ` parent=${parentSpanId}` : '';
+        process.stderr.write(`[telemetry] ${kind} ${label} span=${spanId !== null && spanId !== void 0 ? spanId : 'none'}${parent}${suffix}\n`);
+    }
+}
+class OtlpHttpTelemetrySink {
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+        this.activeSpans = new Map();
+        this.pendingExports = new Set();
+    }
+    startSpan(name, parentSpanId, attributes) {
+        var _a;
+        const parentSpan = parentSpanId ? this.activeSpans.get(parentSpanId) : undefined;
+        const spanId = (0, node_crypto_1.randomBytes)(8).toString('hex');
+        const spanRecord = {
+            traceId: (_a = parentSpan === null || parentSpan === void 0 ? void 0 : parentSpan.traceId) !== null && _a !== void 0 ? _a : (0, node_crypto_1.randomBytes)(16).toString('hex'),
+            spanId,
+            parentSpanId,
+            name,
+            startTimeUnixNano: currentTimeUnixNano(),
+            attributes: toOtlpAttributes(sanitizeAttributes(attributes)),
+            events: [],
+        };
+        this.activeSpans.set(spanId, spanRecord);
+        return {
+            id: spanId,
+            end: (status) => {
+                this.endSpan(spanId, status);
+            },
+            recordException: (error, exceptionAttributes) => {
+                this.emitException(error, spanId, exceptionAttributes);
+            },
+        };
+    }
+    emitDecisionEvent(name, spanId, attributes) {
+        const spanRecord = spanId ? this.activeSpans.get(spanId) : undefined;
+        if (!spanRecord) {
+            return;
+        }
+        const schema = exports.TELEMETRY_DECISION_EVENT_SCHEMA[name];
+        spanRecord.events.push({
+            timeUnixNano: currentTimeUnixNano(),
+            name,
+            attributes: toOtlpAttributes(sanitizeAttributes(attributes, schema.allowedAttributes)),
+        });
+    }
+    emitException(error, spanId, attributes) {
+        var _a, _b;
+        const spanRecord = spanId ? this.activeSpans.get(spanId) : undefined;
+        if (!spanRecord) {
+            return;
+        }
+        const normalized = normalizeError(error);
+        spanRecord.events.push({
+            timeUnixNano: currentTimeUnixNano(),
+            name: 'exception',
+            attributes: [
+                ...toOtlpAttributes({
+                    'exception.type': String((_a = normalized.name) !== null && _a !== void 0 ? _a : 'UnknownError'),
+                    'exception.message': String((_b = normalized.message) !== null && _b !== void 0 ? _b : ''),
+                }),
+                ...toOtlpAttributes(sanitizeAttributes(attributes)),
+            ],
+        });
+    }
+    async flush() {
+        await Promise.allSettled([...this.pendingExports]);
+    }
+    endSpan(spanId, status) {
+        const spanRecord = this.activeSpans.get(spanId);
+        if (!spanRecord) {
+            return;
+        }
+        this.activeSpans.delete(spanId);
+        const payload = {
+            resourceSpans: [
+                {
+                    resource: {
+                        attributes: toOtlpAttributes({
+                            'service.name': 'ztd-cli',
+                            'telemetry.export.mode': 'otlp',
+                        }),
+                    },
+                    scopeSpans: [
+                        {
+                            scope: {
+                                name: '@rawsql-ts/ztd-cli',
+                            },
+                            spans: [
+                                {
+                                    traceId: spanRecord.traceId,
+                                    spanId: spanRecord.spanId,
+                                    parentSpanId: spanRecord.parentSpanId,
+                                    name: spanRecord.name,
+                                    kind: 1,
+                                    startTimeUnixNano: spanRecord.startTimeUnixNano,
+                                    endTimeUnixNano: currentTimeUnixNano(),
+                                    attributes: spanRecord.attributes,
+                                    events: spanRecord.events,
+                                    status: {
+                                        code: status === 'ok' ? OTLP_STATUS_OK : OTLP_STATUS_ERROR,
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        };
+        const exportPromise = fetch(this.endpoint, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        })
+            .then(() => undefined)
+            .catch(() => undefined)
+            .finally(() => {
+            this.pendingExports.delete(exportPromise);
+        });
+        this.pendingExports.add(exportPromise);
+    }
+}
+const NOOP_SINK = new NoopTelemetrySink();
+let telemetrySink = NOOP_SINK;
+let telemetryEnabled = false;
+let telemetryExportMode = 'console';
+const spanStack = [];
+function resolveTelemetryEnabled(explicit) {
+    if (typeof explicit === 'boolean') {
+        return explicit;
+    }
+    if (typeof explicit === 'string') {
+        return isTruthy(explicit);
+    }
+    return isTruthy(process.env[TELEMETRY_ENABLED_ENV]);
+}
+function resolveTelemetryExportMode(explicit) {
+    return normalizeTelemetryExportMode(explicit !== null && explicit !== void 0 ? explicit : process.env[TELEMETRY_EXPORT_ENV]);
+}
+function resolveTelemetryFilePath(explicit) {
+    var _a;
+    return (_a = explicit !== null && explicit !== void 0 ? explicit : process.env[TELEMETRY_FILE_ENV]) !== null && _a !== void 0 ? _a : DEFAULT_FILE_EXPORT_PATH;
+}
+function resolveTelemetryOtlpEndpoint(explicit) {
+    var _a;
+    return (_a = explicit !== null && explicit !== void 0 ? explicit : process.env[TELEMETRY_OTLP_ENDPOINT_ENV]) !== null && _a !== void 0 ? _a : DEFAULT_OTLP_HTTP_ENDPOINT;
+}
+function setTelemetryEnabled(enabled) {
+    process.env[TELEMETRY_ENABLED_ENV] = enabled ? '1' : '0';
+}
+function configureTelemetry(options = {}) {
+    telemetryEnabled = resolveTelemetryEnabled(options.enabled);
+    telemetryExportMode = resolveTelemetryExportMode(options.exportMode);
+    if (!telemetryEnabled) {
+        telemetrySink = NOOP_SINK;
+        spanStack.length = 0;
+        return;
+    }
+    telemetrySink = createTelemetrySink({
+        exportMode: telemetryExportMode,
+        filePath: resolveTelemetryFilePath(options.filePath),
+        otlpEndpoint: resolveTelemetryOtlpEndpoint(options.otlpEndpoint),
+    });
+    spanStack.length = 0;
+}
+function isTelemetryEnabled() {
+    return telemetryEnabled;
+}
+function getTelemetryExportMode() {
+    return telemetryExportMode;
+}
+async function flushTelemetry() {
+    await telemetrySink.flush();
+}
+function beginCommandSpan(commandName, attributes = {}) {
+    if (!telemetryEnabled) {
+        return;
+    }
+    spanStack.length = 0;
+    const rootSpan = telemetrySink.startSpan(commandName, undefined, {
+        ...attributes,
+        scope: 'command-root',
+    });
+    spanStack.push(rootSpan);
+}
+function finishCommandSpan(status = 'ok') {
+    var _a, _b;
+    if (!telemetryEnabled) {
+        return;
+    }
+    while (spanStack.length > 1) {
+        (_a = spanStack.pop()) === null || _a === void 0 ? void 0 : _a.end(status);
+    }
+    (_b = spanStack.pop()) === null || _b === void 0 ? void 0 : _b.end(status);
+}
+async function withSpan(name, fn, attributes = {}) {
+    var _a;
+    if (!telemetryEnabled) {
+        return await fn();
+    }
+    const parentSpanId = (_a = getCurrentSpan()) === null || _a === void 0 ? void 0 : _a.id;
+    const span = telemetrySink.startSpan(name, parentSpanId, attributes);
+    spanStack.push(span);
+    try {
+        const result = await fn();
+        span.end('ok');
+        return result;
+    }
+    catch (error) {
+        span.recordException(error);
+        span.end('error');
+        throw error;
+    }
+    finally {
+        removeSpan(span.id);
+    }
+}
+function withSpanSync(name, fn, attributes = {}) {
+    var _a;
+    if (!telemetryEnabled) {
+        return fn();
+    }
+    const parentSpanId = (_a = getCurrentSpan()) === null || _a === void 0 ? void 0 : _a.id;
+    const span = telemetrySink.startSpan(name, parentSpanId, attributes);
+    spanStack.push(span);
+    try {
+        const result = fn();
+        span.end('ok');
+        return result;
+    }
+    catch (error) {
+        span.recordException(error);
+        span.end('error');
+        throw error;
+    }
+    finally {
+        removeSpan(span.id);
+    }
+}
+function emitDecisionEvent(name, attributes = {}) {
+    var _a;
+    if (!telemetryEnabled) {
+        return;
+    }
+    telemetrySink.emitDecisionEvent(name, (_a = getCurrentSpan()) === null || _a === void 0 ? void 0 : _a.id, attributes);
+}
+function recordException(error, attributes = {}) {
+    if (!telemetryEnabled) {
+        return;
+    }
+    const currentSpan = getCurrentSpan();
+    if (currentSpan) {
+        currentSpan.recordException(error, attributes);
+        return;
+    }
+    telemetrySink.emitException(error, undefined, attributes);
+}
+function createTelemetrySink(options) {
+    switch (options.exportMode) {
+        case 'console':
+            return new JsonLinesTelemetrySink((line) => {
+                process.stderr.write(`${line}\n`);
+            });
+        case 'debug':
+            return new DebugTelemetrySink();
+        case 'file': {
+            const absoluteFile = (0, node_path_1.resolve)(process.cwd(), options.filePath);
+            (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(absoluteFile), { recursive: true });
+            return new JsonLinesTelemetrySink((line) => {
+                (0, node_fs_1.appendFileSync)(absoluteFile, `${line}\n`, 'utf8');
+            });
+        }
+        case 'otlp':
+            return new OtlpHttpTelemetrySink(options.otlpEndpoint);
+        default:
+            return NOOP_SINK;
+    }
+}
+function buildTelemetryEnvelope(payload) {
+    return {
+        schemaVersion: DEFAULT_SCHEMA_VERSION,
+        type: 'telemetry',
+        timestamp: new Date().toISOString(),
+        ...payload,
+    };
+}
+function getCurrentSpan() {
+    return spanStack[spanStack.length - 1];
+}
+function removeSpan(spanId) {
+    const index = spanStack.findIndex((span) => span.id === spanId);
+    if (index >= 0) {
+        spanStack.splice(index, 1);
+    }
+}
+function isTruthy(value) {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function normalizeTelemetryExportMode(value) {
+    switch ((value !== null && value !== void 0 ? value : 'console').trim().toLowerCase()) {
+        case 'console':
+        case 'debug':
+        case 'file':
+        case 'otlp':
+            return (value !== null && value !== void 0 ? value : 'console').trim().toLowerCase();
+        default:
+            return 'console';
+    }
+}
+function sanitizeAttributes(attributes = {}, allowedKeys) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(attributes)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (allowedKeys && !allowedKeys.includes(key)) {
+            continue;
+        }
+        sanitized[key] = sanitizeAttributeValue(key, value);
+    }
+    return sanitized;
+}
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: sanitizeStringValue('message', error.message),
+        };
+    }
+    return {
+        name: 'UnknownError',
+        message: sanitizeStringValue('message', String(error)),
+    };
+}
+function sanitizeAttributeValue(key, value) {
+    if (value === null || typeof value === 'number' || typeof value === 'boolean') {
+        return isSensitiveAttributeKey(key) ? REDACTED_VALUE : value;
+    }
+    return sanitizeStringValue(key, value);
+}
+// Telemetry safety policy intentionally distinguishes secrets from bulky but benign data. DSN detection covers both URL-style and libpq-style forms, while oversized or multiline values are truncated instead of redacted so exporters keep the boundary without leaking payload bodies.
+function sanitizeStringValue(key, value) {
+    if (isSensitiveAttributeKey(key) || looksSensitive(value)) {
+        return REDACTED_VALUE;
+    }
+    if (value.includes('\n') || value.length > MAX_ATTRIBUTE_STRING_LENGTH) {
+        return `[TRUNCATED:${value.length}]`;
+    }
+    return value;
+}
+function isSensitiveAttributeKey(key) {
+    return [
+        /(?:^|\.)(?:sql|sqlText|query|queryText|statement)$/iu,
+        /(?:dsn|databaseUrl|connectionUrl|url|uri)$/iu,
+        /(?:password|secret|credential|authorization|api(?:_|-)?key|access(?:_|-)?key|(?:auth|bearer|access|refresh|session)?token)$/iu,
+        /(?:bindValue|bindValues|paramValue|paramValues)$/iu,
+        /(?:stack|dump)$/iu,
+    ].some((pattern) => pattern.test(key));
+}
+function looksSensitive(value) {
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        return false;
+    }
+    return [
+        /\b(?:postgres(?:ql)?|mysql|mssql|redis):\/\/\S+/iu,
+        /\b(?:host|hostaddr|port|dbname|db|user|password|passfile|service|sslmode|sslcert|sslkey|sslrootcert|target_session_attrs)\s*=\s*(?:"[^"]*"|'[^']*'|[^\s]+)/iu,
+        /\b(?:password|pwd|secret|token|api(?:key|_key)|access(?:key|_key)|authorization)\s*[=:]\s*\S+/iu,
+        /\b(?:bearer|basic)\s+[A-Za-z0-9._~+\/=:-]{8,}\b/iu,
+        /\b(?:select|insert|update|delete|create|alter|drop|with)\b[\s\S]{0,120}\b(?:from|into|table|view|where|values|set)\b/iu,
+    ].some((pattern) => pattern.test(normalized));
+}
+function toOtlpAttributes(attributes) {
+    return Object.entries(attributes).map(([key, value]) => ({
+        key,
+        value: toOtlpAnyValue(value),
+    }));
+}
+function toOtlpAnyValue(value) {
+    if (value === null) {
+        return { stringValue: 'null' };
+    }
+    if (typeof value === 'boolean') {
+        return { boolValue: value };
+    }
+    if (typeof value === 'number') {
+        return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };
+    }
+    return { stringValue: value };
+}
+function currentTimeUnixNano() {
+    return (BigInt(Date.now()) * BigInt(1000000)).toString();
+}
+function roundDuration(value) {
+    return Math.round(value * 1000) / 1000;
+}
+//# sourceMappingURL=telemetry.js.map