feat(sdk-metrics,sdk-logs,sdk-trace-base): ConsoleMetricExporter,

ConsoleLogRecordExporter, and ConsoleSpanExporter fallback to
console.log when console.dir is unavailable

Author: btomaj

experimental/packages/sdk-logs/src/export/ConsoleLogRecordExporter.ts

@@ -23,6 +23,28 @@ import {
 import type { ReadableLogRecord } from './ReadableLogRecord';
 import type { LogRecordExporter } from './LogRecordExporter';
 
+function log(payload: unknown): void {
+  /* eslint-disable-next-line no-console */
+  if (typeof console?.dir === 'function') {
+    /* eslint-disable-next-line no-console */
+    console.dir(payload, { depth: null });
+    return;
+  }
+
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(payload, null, 2);
+  } catch {
+    serialized = String(payload);
+  }
+
+  /* eslint-disable-next-line no-console */
+  if (typeof console?.log === 'function') {
+    /* eslint-disable-next-line no-console */
+    console.log(serialized);
+  }
+}
+
 /**
  * This is implementation of {@link LogRecordExporter} that prints LogRecords to the
  * console. This class can be used for diagnostic purposes.
@@ -82,7 +104,7 @@ export class ConsoleLogRecordExporter implements LogRecordExporter {
     done?: (result: ExportResult) => void
   ): void {
     for (const logRecord of logRecords) {
-      console.dir(this._exportInfo(logRecord), { depth: null });
+      log(this._exportInfo(logRecord));
     }
     done?.({ code: ExportResultCode.SUCCESS });
   }

experimental/packages/sdk-logs/test/common/export/ConsoleLogRecordExporter.test.ts

@@ -105,5 +105,27 @@ describe('ConsoleLogRecordExporter', () => {
       const options = consoleArgs[1];
       assert.strictEqual(options?.depth, null);
     });
+
+    it('falls back to console.log when console.dir is unavailable', () => {
+      const previousConsoleDir = console.dir;
+      console.dir = undefined as unknown as typeof console.dir;
+
+      const consoleExporter = new ConsoleLogRecordExporter();
+      const spyConsoleLog = sinon.spy(console, 'log');
+      const provider = new LoggerProvider({
+        processors: [new SimpleLogRecordProcessor(consoleExporter)],
+      });
+
+      provider.getLogger('fallback').emit({ body: 'test fallback' });
+
+      assert.ok(spyConsoleLog.called);
+      const loggedPayload = spyConsoleLog.args[0][0];
+      assert.ok(loggedPayload.includes('\n  "body"'));
+      const parsedPayload = JSON.parse(loggedPayload);
+      assert.strictEqual(parsedPayload.body, 'test fallback');
+
+      spyConsoleLog.restore();
+      console.dir = previousConsoleDir;
+    });
   });
 });

packages/opentelemetry-sdk-trace-base/src/export/ConsoleSpanExporter.ts

@@ -22,6 +22,28 @@ import {
   hrTimeToMicroseconds,
 } from '@opentelemetry/core';
 
+function log(payload: unknown): void {
+  /* eslint-disable-next-line no-console */
+  if (typeof console?.dir === 'function') {
+    /* eslint-disable-next-line no-console */
+    console.dir(payload, { depth: null });
+    return;
+  }
+
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(payload, null, 2);
+  } catch {
+    serialized = String(payload);
+  }
+
+  /* eslint-disable-next-line no-console */
+  if (typeof console?.log === 'function') {
+    /* eslint-disable-next-line no-console */
+    console.log(serialized);
+  }
+}
+
 /**
  * This is implementation of {@link SpanExporter} that prints spans to the
  * console. This class can be used for diagnostic purposes.
@@ -93,7 +115,7 @@ export class ConsoleSpanExporter implements SpanExporter {
     done?: (result: ExportResult) => void
   ): void {
     for (const span of spans) {
-      console.dir(this._exportInfo(span), { depth: null });
+      log(this._exportInfo(span));
     }
     if (done) {
       return done({ code: ExportResultCode.SUCCESS });

packages/opentelemetry-sdk-trace-base/test/common/export/ConsoleSpanExporter.test.ts

@@ -126,6 +126,30 @@ describe('ConsoleSpanExporter', () => {
       assert.strictEqual(options?.depth, null);
     });
 
+    it('falls back to console.log when console.dir is unavailable', () => {
+      const previousConsoleDir = console.dir;
+      console.dir = undefined as unknown as typeof console.dir;
+
+      consoleExporter = new ConsoleSpanExporter();
+      const basicTracerProvider = new BasicTracerProvider({
+        sampler: new AlwaysOnSampler(),
+        spanProcessors: [new SimpleSpanProcessor(consoleExporter)],
+      });
+
+      const spyConsoleLog = sinon.spy(console, 'log');
+      const tracer = basicTracerProvider.getTracer('fallback');
+      const span = tracer.startSpan('fallback-span');
+      span.end();
+
+      assert.ok(spyConsoleLog.called);
+      const loggedPayload = spyConsoleLog.args[0][0];
+      assert.ok(loggedPayload.includes('\n  "traceId"'));
+      const parsedPayload = JSON.parse(loggedPayload);
+      assert.strictEqual(parsedPayload.name, 'fallback-span');
+
+      spyConsoleLog.restore();
+      console.dir = previousConsoleDir;
+    });
   });
 
   describe('force flush', () => {

packages/sdk-metrics/src/export/ConsoleMetricExporter.ts

@@ -26,6 +26,28 @@ interface ConsoleMetricExporterOptions {
   temporalitySelector?: AggregationTemporalitySelector;
 }
 
+function log(payload: unknown): void {
+  /* eslint-disable-next-line no-console */
+  if (typeof console?.dir === 'function') {
+    /* eslint-disable-next-line no-console */
+    console.dir(payload, { depth: null });
+    return;
+  }
+
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(payload, null, 2);
+  } catch {
+    serialized = String(payload);
+  }
+
+  /* eslint-disable-next-line no-console */
+  if (typeof console?.log === 'function') {
+    /* eslint-disable-next-line no-console */
+    console.log(serialized);
+  }
+}
+
 /**
  * This is an implementation of {@link PushMetricExporter} that prints metrics to the
  * console. This class can be used for diagnostic purposes.
@@ -77,14 +99,11 @@ export class ConsoleMetricExporter implements PushMetricExporter {
   ): void {
     for (const scopeMetrics of metrics.scopeMetrics) {
       for (const metric of scopeMetrics.metrics) {
-        console.dir(
-          {
-            descriptor: metric.descriptor,
-            dataPointType: metric.dataPointType,
-            dataPoints: metric.dataPoints,
-          },
-          { depth: null }
-        );
+        log({
+          descriptor: metric.descriptor,
+          dataPointType: metric.dataPointType,
+          dataPoints: metric.dataPoints,
+        });
       }
     }
 

packages/sdk-metrics/test/export/ConsoleMetricExporter.test.ts

@@ -156,6 +156,40 @@ describe('ConsoleMetricExporter', () => {
       console.dir = previousConsoleDir;
       await metricReader.shutdown();
     });
+
+    it('falls back to console.log when console.dir is unavailable', async () => {
+      const previousConsoleDir = console.dir;
+      console.dir = undefined as unknown as typeof console.dir;
+
+      const exporter = new ConsoleMetricExporter();
+      const metricReader = new PeriodicExportingMetricReader({
+        exporter,
+        exportIntervalMillis: 100,
+        exportTimeoutMillis: 100,
+      });
+      const meterProvider = new MeterProvider({
+        resource: testResource,
+        readers: [metricReader],
+      });
+      const meter = meterProvider.getMeter('fallback', '1.0.0');
+      const counter = meter.createCounter('counter_total');
+      counter.add(1);
+
+      const spyConsoleLog = sinon.spy(console, 'log');
+      const spyExport = sinon.spy(exporter, 'export');
+
+      await waitForNumberOfExports(spyExport, 1);
+
+      assert.ok(spyConsoleLog.called);
+      const loggedPayload = spyConsoleLog.args[0][0];
+      assert.ok(loggedPayload.includes('\n  "descriptor"'));
+      const parsedPayload = JSON.parse(loggedPayload);
+      assert.strictEqual(parsedPayload.descriptor.name, 'counter_total');
+
+      spyConsoleLog.restore();
+      console.dir = previousConsoleDir;
+      await metricReader.shutdown();
+    });
   });
 
   describe('constructor', () => {