fix(sandbox): fix serialization of error with circular references

src/utils.ts

@@ -212,14 +212,28 @@ export const parseObjectValues = (obj: {
   return accumulator;
 };
 
+const getCircularReplacer = (rootReference: any) => {
+  const references = new WeakSet();
+  references.add(rootReference);
+  return (_: string, value: any) => {
+    if (typeof value === 'object' && value !== null) {
+      if (references.has(value)) {
+        return '[Circular]';
+      }
+      references.add(value);
+    }
+    return value;
+  };
+};
+
 export const errorToJSON = (value: any): Record<string, any> => {
   const error: Record<string, any> = {};
 
   Object.getOwnPropertyNames(value).forEach(function (propName: string) {
     error[propName] = value[propName];
   });
 
-  return error;
+  return JSON.parse(JSON.stringify(error, getCircularReplacer(value)));
 };
 
 const INFINITY = 1 / 0;

tests/fixtures/fixture_processor_fail_with_circular_reference.js

@@ -0,0 +1,16 @@
+/**
+ * A processor file to be used in tests.
+ *
+ */
+'use strict';
+
+const delay = require('./delay');
+
+module.exports = function (/*job*/) {
+  return delay(500).then(() => {
+    const error = new Error('error');
+    error.reference = error;
+
+    throw error;
+  });
+};

tests/test_sandboxed_process.ts

@@ -947,6 +947,47 @@ function sandboxProcessTests(
       await worker.close();
     });
 
+    it('should process and fail when circular reference', async () => {
+      const processFile =
+        __dirname +
+        '/fixtures/fixture_processor_fail_with_circular_reference.js';
+
+      const worker = new Worker(queueName, processFile, {
+        connection,
+        prefix,
+        drainDelay: 1,
+        useWorkerThreads,
+      });
+
+      const failing = new Promise<void>((resolve, reject) => {
+        worker.on('failed', async (job, err) => {
+          try {
+            expect(job.data).eql({ foo: 'bar' });
+            expect(job.failedReason).eql('error');
+            expect(err.message).eql('error');
+            expect(err.stack).include(
+              'fixture_processor_fail_with_circular_reference.js',
+            );
+            expect(err.reference).to.equal('[Circular]');
+            expect(Object.keys(worker['childPool'].retained)).to.have.lengthOf(
+              0,
+            );
+            expect(worker['childPool'].getAllFree()).to.have.lengthOf(1);
+
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+      });
+
+      await queue.add('test', { foo: 'bar' });
+
+      await failing;
+
+      await worker.close();
+    });
+
     it('should error if processor file is missing', async () => {
       let worker;
       let didThrow = false;