fix(sdk-logs,sdk-trace-base,sdk-metrics): #5800

ConsoleSpanExporter, ConsoleMetricExporter, and ConsoleLogRecordExporter use console.log instead of console.dir

Author: btomaj

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

@@ -23,6 +23,22 @@ import {
 import type { ReadableLogRecord } from './ReadableLogRecord';
 import type { LogRecordExporter } from './LogRecordExporter';
 
+function log(payload: unknown): void {
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(
+      payload,
+      (_key, value) => (value === undefined ? null : value),
+      2
+    );
+  } catch {
+    serialized = String(payload);
+  }
+
+  /* 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 +98,7 @@ export class ConsoleLogRecordExporter implements LogRecordExporter {
     done?: (result: ExportResult) => void
   ): void {
     for (const logRecord of logRecords) {
-      console.dir(this._exportInfo(logRecord), { depth: 3 });
+      log(this._exportInfo(logRecord));
     }
     done?.({ code: ExportResultCode.SUCCESS });
   }

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

@@ -26,15 +26,8 @@ import {
 
 /* eslint-disable no-console */
 describe('ConsoleLogRecordExporter', () => {
-  let previousConsoleDir: typeof console.dir;
-
-  beforeEach(() => {
-    previousConsoleDir = console.dir;
-    console.dir = () => {};
-  });
-
   afterEach(() => {
-    console.dir = previousConsoleDir;
+    sinon.restore();
   });
 
   describe('export', () => {
@@ -43,7 +36,7 @@ describe('ConsoleLogRecordExporter', () => {
         const instrumentationScopeName = '@opentelemetry/sdk-logs/test';
         const instrumentationScopeVersion = '1.2.3';
         const consoleExporter = new ConsoleLogRecordExporter();
-        const spyConsole = sinon.spy(console, 'dir');
+        const stubConsole = sinon.stub(console, 'log');
         const spyExport = sinon.spy(consoleExporter, 'export');
         const provider = new LoggerProvider({
           processors: [new SimpleLogRecordProcessor(consoleExporter)],
@@ -59,8 +52,8 @@ describe('ConsoleLogRecordExporter', () => {
 
         const logRecords = spyExport.args[0];
         const firstLogRecord = logRecords[0][0];
-        const consoleArgs = spyConsole.args[0];
-        const consoleLogRecord = consoleArgs[0];
+        const loggedPayload = stubConsole.args[0][0];
+        const consoleLogRecord = JSON.parse(loggedPayload);
         const keys = Object.keys(consoleLogRecord).sort().join(',');
 
         const expectedKeys = [
@@ -89,7 +82,30 @@ describe('ConsoleLogRecordExporter', () => {
         );
 
         assert.ok(spyExport.calledOnce);
+        assert.ok(stubConsole.calledOnce);
       });
     });
+
+    it('should serialize log record using String() when JSON fails', () => {
+      const consoleExporter = new ConsoleLogRecordExporter();
+      const stubConsole = sinon.stub(console, 'log');
+      const originalStringify = JSON.stringify;
+      let shouldThrow = true;
+      sinon.stub(JSON, 'stringify').callsFake((...args) => {
+        if (shouldThrow) {
+          shouldThrow = false;
+          throw new Error('boom');
+        }
+        return originalStringify(...args);
+      });
+      const provider = new LoggerProvider({
+        processors: [new SimpleLogRecordProcessor(consoleExporter)],
+      });
+
+      provider.getLogger('test').emit({ body: 'trigger fallback' });
+
+      assert.ok(stubConsole.calledOnce);
+      assert.strictEqual(stubConsole.args[0][0], '[object Object]');
+    });
   });
 });

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

@@ -22,6 +22,22 @@ import {
   hrTimeToMicroseconds,
 } from '@opentelemetry/core';
 
+function log(payload: unknown): void {
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(
+      payload,
+      (_key, value) => (value === undefined ? null : value),
+      2
+    );
+  } catch {
+    serialized = String(payload);
+  }
+
+  /* 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 +109,7 @@ export class ConsoleSpanExporter implements SpanExporter {
     done?: (result: ExportResult) => void
   ): void {
     for (const span of spans) {
-      console.dir(this._exportInfo(span), { depth: 3 });
+      log(this._exportInfo(span));
     }
     if (done) {
       return done({ code: ExportResultCode.SUCCESS });

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

@@ -28,16 +28,13 @@ import {
 /* eslint-disable no-console */
 describe('ConsoleSpanExporter', () => {
   let consoleExporter: ConsoleSpanExporter;
-  let previousConsoleDir: any;
 
   beforeEach(() => {
-    previousConsoleDir = console.dir;
-    console.dir = () => {};
     consoleExporter = new ConsoleSpanExporter();
   });
 
   afterEach(() => {
-    console.dir = previousConsoleDir;
+    sinon.restore();
   });
 
   describe('.export()', () => {
@@ -49,7 +46,7 @@ describe('ConsoleSpanExporter', () => {
           spanProcessors: [new SimpleSpanProcessor(consoleExporter)],
         });
 
-        const spyConsole = sinon.spy(console, 'dir');
+        const stubConsole = sinon.stub(console, 'log');
         const spyExport = sinon.spy(consoleExporter, 'export');
 
         const instrumentationScopeName = '@opentelemetry/sdk-trace-base/test';
@@ -73,8 +70,8 @@ describe('ConsoleSpanExporter', () => {
         const spans = spyExport.args[0];
         const firstSpan = spans[0][0];
         const firstEvent = firstSpan.events[0];
-        const consoleArgs = spyConsole.args[0];
-        const consoleSpan = consoleArgs[0];
+        const loggedPayload = stubConsole.args[0][0];
+        const consoleSpan = JSON.parse(loggedPayload);
         const keys = Object.keys(consoleSpan).sort().join(',');
 
         const expectedKeys = [
@@ -106,8 +103,34 @@ describe('ConsoleSpanExporter', () => {
         );
 
         assert.ok(spyExport.calledOnce);
+        assert.ok(stubConsole.calledOnce);
       });
     });
+
+    it('should serialize span information using String() when JSON fails', () => {
+      const basicTracerProvider = new BasicTracerProvider({
+        sampler: new AlwaysOnSampler(),
+        spanProcessors: [new SimpleSpanProcessor(consoleExporter)],
+      });
+
+      const stubConsole = sinon.stub(console, 'log');
+      const originalStringify = JSON.stringify;
+      let shouldThrow = true;
+      sinon.stub(JSON, 'stringify').callsFake((...args) => {
+        if (shouldThrow) {
+          shouldThrow = false;
+          throw new Error('boom');
+        }
+        return originalStringify(...args);
+      });
+
+      const tracer = basicTracerProvider.getTracer('fallback-string');
+      const span = tracer.startSpan('fallback-span');
+      span.end();
+
+      assert.ok(stubConsole.calledOnce);
+      assert.strictEqual(stubConsole.args[0][0], '[object Object]');
+    });
   });
 
   describe('force flush', () => {

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

@@ -26,6 +26,22 @@ interface ConsoleMetricExporterOptions {
   temporalitySelector?: AggregationTemporalitySelector;
 }
 
+function log(payload: unknown): void {
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(
+      payload,
+      (_key, value) => (value === undefined ? null : value),
+      2
+    );
+  } catch {
+    serialized = String(payload);
+  }
+
+  /* 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 +93,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

@@ -47,16 +47,12 @@ async function waitForNumberOfExports(
 /* eslint-disable no-console */
 describe('ConsoleMetricExporter', () => {
   describe('export', () => {
-    let previousConsoleDir: any;
     let exporter: ConsoleMetricExporter;
     let meterProvider: MeterProvider;
     let metricReader: PeriodicExportingMetricReader;
     let meter: metrics.Meter;
 
     beforeEach(() => {
-      previousConsoleDir = console.dir;
-      console.dir = () => {};
-
       exporter = new ConsoleMetricExporter();
       metricReader = new PeriodicExportingMetricReader({
         exporter: exporter,
@@ -71,9 +67,8 @@ describe('ConsoleMetricExporter', () => {
     });
 
     afterEach(async () => {
-      console.dir = previousConsoleDir;
-
       await metricReader.shutdown();
+      sinon.restore();
     });
 
     it('should export information about metric', async () => {
@@ -91,14 +86,14 @@ describe('ConsoleMetricExporter', () => {
       histogram.record(100);
       histogram.record(1000);
 
-      const spyConsole = sinon.spy(console, 'dir');
+      const stubConsole = sinon.stub(console, 'log');
       const spyExport = sinon.spy(exporter, 'export');
 
       await waitForNumberOfExports(spyExport, 1);
       const resourceMetrics = spyExport.args[0];
       const firstResourceMetric = resourceMetrics[0];
-      const consoleArgs = spyConsole.args[0];
-      const consoleMetric = consoleArgs[0];
+      const loggedPayload = stubConsole.args[0][0];
+      const consoleMetric = JSON.parse(loggedPayload);
       const keys = Object.keys(consoleMetric).sort().join(',');
 
       const expectedKeys = ['dataPointType', 'dataPoints', 'descriptor'].join(
@@ -124,6 +119,29 @@ describe('ConsoleMetricExporter', () => {
       );
 
       assert.ok(spyExport.calledOnce);
+      assert.ok(stubConsole.called);
+    });
+
+    it('should serialize metric information using String() when JSON fails', async () => {
+      const stubConsole = sinon.stub(console, 'log');
+      const originalStringify = JSON.stringify;
+      let shouldThrow = true;
+      sinon.stub(JSON, 'stringify').callsFake((...args) => {
+        if (shouldThrow) {
+          shouldThrow = false;
+          throw new Error('boom');
+        }
+        return originalStringify(...args);
+      });
+
+      const counter = meter.createCounter('fallback_counter');
+      counter.add(1);
+
+      const spyExport = sinon.spy(exporter, 'export');
+      await waitForNumberOfExports(spyExport, 1);
+
+      assert.ok(stubConsole.calledOnce);
+      assert.strictEqual(stubConsole.args[0][0], '[object Object]');
     });
   });