@obsrviq/otel-console 0.1.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@obsrviq/otel-console",
+  "version": "0.1.0",
+  "description": "Bridge bare console.* to correlated OTLP logs — reads the active OpenTelemetry span so console.log joins the trace.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./register.cjs",
+  "exports": {
+    ".": "./register.cjs",
+    "./register": "./register.cjs"
+  },
+  "files": [
+    "register.cjs"
+  ],
+  "peerDependencies": {
+    "@opentelemetry/api": "*"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    }
+  }
+}

package/register.cjs

@@ -0,0 +1,96 @@
+'use strict';
+/**
+ * @obsrviq/otel-console — bridge bare `console.*` to correlated OTLP logs.
+ *
+ *   node -r @obsrviq/otel-console/register app.js
+ *   # or: NODE_OPTIONS="--require @obsrviq/otel-console/register"
+ *
+ * The trick: it reads the ACTIVE OpenTelemetry span at the moment console.* is
+ * called — in-process, synchronously, where the async context still exists — so a
+ * `console.log("...")` inside a traced request carries that request's trace_id and
+ * joins to the backend trace (and thence the session replay). No code changes, no
+ * structured logger required. Degrades to trace-less logs if OTel isn't present,
+ * and NEVER throws into or breaks the host app.
+ *
+ * Config (env): OBSRVIQ_KEY (pk_ ingest key, required), and an endpoint from
+ * OBSRVIQ_LOGS_ENDPOINT or OTEL_EXPORTER_OTLP_ENDPOINT (required). OTEL_SERVICE_NAME
+ * names the service. Missing key/endpoint → no-op (console untouched).
+ */
+
+const util = require('util');
+
+const ENDPOINT = (process.env.OBSRVIQ_LOGS_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || '').replace(/\/+$/, '');
+const KEY = process.env.OBSRVIQ_KEY || process.env.OBSRVIQ_INGEST_KEY || '';
+const SERVICE = process.env.OTEL_SERVICE_NAME || process.env.OBSRVIQ_SERVICE || 'node';
+const FLUSH_MS = Number(process.env.OBSRVIQ_LOGS_FLUSH_MS) || 2000;
+const MAX_BATCH = 256;
+
+if (!ENDPOINT || !KEY) {
+  // Misconfigured → do nothing at all (never patch console), so we can't break apps.
+  module.exports = { enabled: false };
+  return;
+}
+
+// Read the active span via @opentelemetry/api if the app is instrumented (it is,
+// whenever traces work). Optional — absence just means trace-less logs.
+let otelTrace = null;
+try { otelTrace = require('@opentelemetry/api').trace; } catch (_e) { /* not instrumented */ }
+
+const SEV = { debug: 5, log: 9, info: 9, warn: 13, error: 17 };
+const buf = [];
+const orig = {};
+let sending = false;
+
+function activeCtx() {
+  if (!otelTrace) return { traceId: '', spanId: '' };
+  const span = otelTrace.getActiveSpan && otelTrace.getActiveSpan();
+  const c = span && span.spanContext && span.spanContext();
+  return c ? { traceId: c.traceId || '', spanId: c.spanId || '' } : { traceId: '', spanId: '' };
+}
+
+function record(method, args) {
+  const { traceId, spanId } = activeCtx();
+  buf.push({
+    timeUnixNano: String(Date.now()) + '000000',
+    severityNumber: SEV[method] || 9,
+    severityText: method.toUpperCase(),
+    body: { stringValue: util.format.apply(util, args).slice(0, 8192) },
+    traceId: traceId,
+    spanId: spanId,
+  });
+  if (buf.length >= MAX_BATCH) flush();
+}
+
+function flush() {
+  if (!buf.length || sending || typeof fetch !== 'function') return Promise.resolve();
+  const records = buf.splice(0, buf.length);
+  const payload = {
+    resourceLogs: [{
+      resource: { attributes: [{ key: 'service.name', value: { stringValue: SERVICE } }] },
+      scopeLogs: [{ logRecords: records }],
+    }],
+  };
+  sending = true;
+  return fetch(ENDPOINT + '/v1/logs', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', 'x-obsrviq-key': KEY },
+    body: JSON.stringify(payload),
+  }).catch(function () { /* best-effort; never surface to the app */ })
+    .finally(function () { sending = false; });
+}
+
+['debug', 'log', 'info', 'warn', 'error'].forEach(function (m) {
+  if (typeof console[m] !== 'function') return;
+  orig[m] = console[m].bind(console);
+  console[m] = function () {
+    try { record(m, Array.prototype.slice.call(arguments)); } catch (_e) { /* swallow */ }
+    return orig[m].apply(console, arguments);
+  };
+});
+
+const timer = setInterval(flush, FLUSH_MS);
+if (timer.unref) timer.unref();
+process.on('beforeExit', flush);
+process.on('SIGTERM', function () { flush(); });
+
+module.exports = { enabled: true, flush: flush };