add console.error for async TranscriptLogger.logActivity() impl in TranscriptLoggerMiddleware

libraries/botbuilder-core/src/transcriptLogger.ts

@@ -92,10 +92,23 @@ export class TranscriptLoggerMiddleware implements Middleware {
         while (this.transcript.length > 0) {
             try {
                 const activity: Activity = this.transcript.shift();
-                this.logger.logActivity(activity);
+                // If the implementation of this.logger.logActivity() is asynchronous, we don't
+                // await it as to not block processing of activities.
+                // Because TranscriptLogger.logActivity() returns void or Promise<void>, we capture
+                // the result and see if it is a Promise.
+                const logActivityResult = this.logger.logActivity(activity);
+
+                // If this.logger.logActivity() returns a Promise, a catch is added in case there
+                // is no innate error handling in the method. This catch prevents
+                // UnhandledPromiseRejectionWarnings from being thrown and prints the error to the
+                // console.
+                if (logActivityResult instanceof Promise) {
+                    logActivityResult.catch(err => {
+                        this.transcriptLoggerErrorHandler(err);
+                    });
+                }
             } catch (err) {
-                // tslint:disable-next-line:no-console
-                console.error('TranscriptLoggerMiddleware logActivity failed', err);
+                this.transcriptLoggerErrorHandler(err);
             }
         }
     }
@@ -119,6 +132,21 @@ export class TranscriptLoggerMiddleware implements Middleware {
     private cloneActivity(activity: Partial<Activity>): Activity {
         return Object.assign(<Activity>{}, activity);
     }
+
+    /**
+     * Error logging helper function.
+     * @param err Error or object to console.error out.
+     */
+    private transcriptLoggerErrorHandler(err: Error|any): void {
+        // tslint:disable:no-console
+        if (err instanceof Error) {
+          console.error(`TranscriptLoggerMiddleware logActivity failed: "${ err.message }"`);
+          console.error(err.stack);
+        } else {
+          console.error(`TranscriptLoggerMiddleware logActivity failed: "${ JSON.stringify(err) }"`);
+        }
+        // tslint:enable:no-console
+      }
 }
 
 /**

libraries/botbuilder-core/tests/transcriptMiddleware.test.js

@@ -1,6 +1,31 @@
 const assert = require('assert');
 const { TestAdapter, TranscriptLoggerMiddleware, MemoryTranscriptStore, ActivityTypes } = require('../');
 
+class SyncErrorLogger {
+    logActivity(activity) {
+        throw new Error();
+    }
+}
+
+class AsyncErrorLogger {
+    async logActivity(activity) {
+        throw new Error();
+    }
+}
+
+class SyncThrowerLogger {
+    logActivity(activity) {
+        throw 1;
+    }
+}
+
+class AsyncThrowerLogger {
+    async logActivity(activity) {
+        throw 2;
+    }
+}
+
+
 describe(`TranscriptLoggerMiddleware`, function () {
     this.timeout(5000);
 
@@ -110,6 +135,67 @@ describe(`TranscriptLoggerMiddleware`, function () {
                 });
             })
     });
+
+    describe('\'s error handling', function () {
+        const originalConsoleError = console.error;
+
+        this.afterEach(function () {
+            console.error = originalConsoleError;
+        })
+
+        function stubConsoleError(done, expectedErrorMessage, expectedErrors = 1) {
+            let errorCounter = 0;      
+            console.error = function (error) {
+                // We only care about the error message on the first error.
+                if (errorCounter === 0) {
+                    if (expectedErrorMessage) {
+                        assert(error.startsWith(expectedErrorMessage), `unexpected error message received: ${ error }`);
+                    } else {
+                        assert(error.startsWith('TranscriptLoggerMiddleware logActivity failed'), `unexpected error message received: ${ error }`);
+                    }
+                }
+                errorCounter++;
+
+                if (expectedErrors === errorCounter)  {
+                    done();
+                } if (errorCounter > expectedErrors) {
+                    throw new Error(`console.error() called too many times.`);
+                }
+            }
+        }
+
+        it(`should print to console errors from synchronous logActivity()`, function (done) {
+            stubConsoleError(done, undefined, 2);
+            var adapter = new TestAdapter(async (context) => {
+            }).use(new TranscriptLoggerMiddleware(new SyncErrorLogger()));
+
+            adapter.send('test');
+        });
+
+        it(`should print to console errors from asynchronous logActivity().`, function (done) {
+            stubConsoleError(done, undefined, 2);
+            var adapter = new TestAdapter(async (context) => {
+            }).use(new TranscriptLoggerMiddleware(new AsyncErrorLogger()));
+
+            adapter.send('test');
+        });
+
+        it(`should print to console thrown info from synchronous logActivity()`, function (done) {
+            stubConsoleError(done, 'TranscriptLoggerMiddleware logActivity failed: "1"');
+            var adapter = new TestAdapter(async (context) => {
+            }).use(new TranscriptLoggerMiddleware(new SyncThrowerLogger()));
+
+            adapter.send('test');
+        });
+
+        it(`should print to console thrown info from asynchronous logActivity().`, function (done) {
+            stubConsoleError(done, 'TranscriptLoggerMiddleware logActivity failed: "2"');
+            var adapter = new TestAdapter(async (context) => {
+            }).use(new TranscriptLoggerMiddleware(new AsyncThrowerLogger()));
+
+            adapter.send('test');
+        });
+    });
 });