test(sdk-logs): add more tests

Author: pichlermarc

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

@@ -83,6 +83,7 @@ describe('BatchLogRecordProcessorBase', () => {
   afterEach(() => {
     exporter.reset();
     sinon.restore();
+    setGlobalErrorHandler(loggingErrorHandler);
   });
 
   describe('constructor', () => {
@@ -396,6 +397,37 @@ describe('BatchLogRecordProcessorBase', () => {
       setGlobalErrorHandler(loggingErrorHandler());
     });
 
+    it('should call globalErrorHandler when export exceeds timeout', async function () {
+      // arrange
+      const clock = sinon.useFakeTimers();
+      const exportTimeoutMillis = 1000;
+      sinon.stub(exporter, 'export').callsFake((_, callback) => {
+        // never call the callback to simulate a hung export
+        // the timeout should trigger instead.
+      });
+      const errorHandlerSpy = sinon.spy();
+      setGlobalErrorHandler(errorHandlerSpy);
+      const processor = new BatchLogRecordProcessor(exporter, {
+        maxExportBatchSize: 1,
+        scheduledDelayMillis: 2500,
+        exportTimeoutMillis,
+      });
+
+      // act
+      processor.onEmit(createLogRecord());
+      await clock.tickAsync(exportTimeoutMillis + 100);
+
+      // assert
+      sinon.assert.calledOnceWithMatch(
+        errorHandlerSpy,
+        sinon.match.instanceOf(Error)
+      );
+      sinon.assert.calledOnceWithMatch(
+        errorHandlerSpy,
+        sinon.match.has('message', 'Timeout')
+      );
+    });
+
     it('should drop logRecords when there are more logRecords than "maxQueueSize"', function () {
       // Use a large batch size to prevent automatic exports during this test
       const maxQueueSize = 6;
@@ -476,6 +508,58 @@ describe('BatchLogRecordProcessorBase', () => {
         'fromasync'
       );
     });
+
+    it('should call forceFlush on exporter when export is in progress', async () => {
+      // arrange
+      let exportCallback: ((result: ExportResult) => void) | undefined;
+      const customExporter: LogRecordExporter = {
+        export: (logs, callback) => {
+          // keep export pending, so that we can resolve it later
+          exportCallback = callback;
+        },
+        shutdown: async () => {},
+        forceFlush: async () => {},
+      };
+      const forceFlushSpy = sinon.spy(customExporter, 'forceFlush');
+      const processor = new BatchLogRecordProcessor(customExporter, {
+        maxExportBatchSize: 1,
+        scheduledDelayMillis: 2500,
+      });
+
+      // emit enough logs to trigger export
+      processor.onEmit(createLogRecord());
+      // yield to allow export to start
+      await new Promise(resolve => setTimeout(resolve, 0));
+      // sanity check - ensure export is indeed in progress
+      assert.ok(exportCallback !== undefined);
+
+      // act
+      const forceFlushPromise = processor.forceFlush();
+      // yield to allow forceFlush to continue
+      await new Promise(resolve => setTimeout(resolve, 0));
+
+      // assert
+      sinon.assert.calledOnce(forceFlushSpy);
+
+      if (exportCallback !== undefined) {
+        exportCallback({ code: ExportResultCode.SUCCESS });
+      }
+      await forceFlushPromise;
+      await processor.shutdown();
+    });
+
+    it('should not call forceFlush on exporter when queue is empty and no export in progress', async function () {
+      // arrange
+      const forceFlushSpy = sinon.spy(exporter, 'forceFlush');
+      const processor = new BatchLogRecordProcessor(exporter);
+
+      // act - nothing in the queue and no export in progress
+      await processor.forceFlush();
+
+      // assert
+      sinon.assert.notCalled(forceFlushSpy);
+      await processor.shutdown();
+    });
   });
 
   describe('shutdown', () => {

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

@@ -95,4 +95,11 @@ describe('ConsoleLogRecordExporter', () => {
       });
     });
   });
+
+  describe('forceFlush', function () {
+    it('should forceFlush without error', async function () {
+      const consoleExporter = new ConsoleLogRecordExporter();
+      await consoleExporter.forceFlush();
+    });
+  });
 });

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

@@ -95,4 +95,11 @@ describe('InMemoryLogRecordExporter', () => {
       assert.strictEqual(memoryExporter.getFinishedLogRecords().length, 0);
     });
   });
+
+  describe('forceFlush', function () {
+    it('should forceFlush without error', async function () {
+      const exporter = new InMemoryLogRecordExporter();
+      await exporter.forceFlush();
+    });
+  });
 });