dd-trace 5.52.0 → 5.53.0

package/README.md

@@ -22,6 +22,11 @@ Most of the documentation for `dd-trace` is available on these webpages:
 
 ## Version Release Lines and Maintenance
 
+> **Node.js v24 Notice**: We're currently adding compatibility for Node.js v24. To use the tracer with your application either continue to use Node.js v22 (LTS), or do both of the following as a workaround:
+> * Install v5.52.0 (or newer) of the tracer
+> * Set `--no-async-context-frame` either using a CLI argument or via `NODE_OPTIONS`
+> Once support for Node.js v24 is complete this flag will no longer be needed.
+
 | Release Line                                             | Latest Version                                                                                         | Node.js  | [SSI](https://docs.datadoghq.com/tracing/trace_collection/automatic_instrumentation/single-step-apm/?tab=linuxhostorvm) | [K8s Injection](https://docs.datadoghq.com/tracing/trace_collection/library_injection_local/?tab=kubernetes) |Status          |Initial Release | End of Life |
 | :---:                                                    | :---:                                                                                                  | :---:    | :---:  | :---:  | :---:           | :---:          | :---:       |
 | [`v1`](https://github.com/DataDog/dd-trace-js/tree/v1.x) | ![npm v1](https://img.shields.io/npm/v/dd-trace/legacy-v1?color=white&label=%20&style=flat-square)     | `>= v12` | NO | NO | **EOL** | 2021-07-13     | 2022-02-25  |

package/index.d.ts

@@ -189,6 +189,7 @@ interface Plugins {
   "http": tracer.plugins.http;
   "http2": tracer.plugins.http2;
   "ioredis": tracer.plugins.ioredis;
+  "iovalkey": tracer.plugins.iovalkey;
   "jest": tracer.plugins.jest;
   "kafkajs": tracer.plugins.kafkajs
   "knex": tracer.plugins.knex;
@@ -855,7 +856,7 @@ declare namespace tracer {
      * @param value The amount to increment the stat by.
      * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    increment(stat: string, value?: number, tags?: Record<string, string|number>): void
+    increment(stat: string, value?: number, tags?: Record<string, string|number> | string[]): void
 
     /**
      * Decrements a metric by the specified value, optionally specifying tags.
@@ -863,7 +864,7 @@ declare namespace tracer {
      * @param value The amount to decrement the stat by.
      * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    decrement(stat: string, value?: number, tags?: Record<string, string|number>): void
+    decrement(stat: string, value?: number, tags?: Record<string, string|number> | string[]): void
 
     /**
      * Sets a distribution value, optionally specifying tags.
@@ -871,7 +872,7 @@ declare namespace tracer {
      * @param value The amount to increment the stat by.
      * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    distribution(stat: string, value?: number, tags?: Record<string, string|number>): void
+    distribution(stat: string, value?: number, tags?: Record<string, string|number> | string[]): void
 
     /**
      * Sets a gauge value, optionally specifying tags.
@@ -879,7 +880,7 @@ declare namespace tracer {
      * @param value The amount to increment the stat by.
      * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    gauge(stat: string, value?: number, tags?: Record<string, string|number>): void
+    gauge(stat: string, value?: number, tags?: Record<string, string|number> | string[]): void
 
     /**
      * Sets a histogram value, optionally specifying tags.
@@ -887,7 +888,7 @@ declare namespace tracer {
      * @param value The amount to increment the stat by.
      * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    histogram(stat: string, value?: number, tags?: Record<string, string|number>): void
+    histogram(stat: string, value?: number, tags?: Record<string, string|number> | string[]): void
 
     /**
      * Forces any unsent metrics to be sent
@@ -1361,7 +1362,7 @@ declare namespace tracer {
      * [child_process](https://nodejs.org/api/child_process.html) module.
      */
     interface child_process extends Instrumentation {}
-  
+
     /**
      * This plugin automatically instruments the
      * [confluentinc-kafka-javascript](https://github.com/confluentinc/confluent-kafka-js) module.
@@ -1666,6 +1667,53 @@ declare namespace tracer {
       splitByInstance?: boolean;
     }
 
+    /**
+     * This plugin automatically instruments the
+     * [iovalkey](https://github.com/valkey-io/iovalkey) module.
+     */
+    interface iovalkey extends Instrumentation {
+      /**
+       * List of commands that should be instrumented. Commands must be in
+       * lowercase for example 'xread'.
+       *
+       * @default /^.*$/
+       */
+      allowlist?: string | RegExp | ((command: string) => boolean) | (string | RegExp | ((command: string) => boolean))[];
+
+      /**
+       * Deprecated in favor of `allowlist`.
+       *
+       * @deprecated
+       * @hidden
+       */
+      whitelist?: string | RegExp | ((command: string) => boolean) | (string | RegExp | ((command: string) => boolean))[];
+
+      /**
+       * List of commands that should not be instrumented. Takes precedence over
+       * allowlist if a command matches an entry in both. Commands must be in
+       * lowercase for example 'xread'.
+       *
+       * @default []
+       */
+      blocklist?: string | RegExp | ((command: string) => boolean) | (string | RegExp | ((command: string) => boolean))[];
+
+      /**
+       * Deprecated in favor of `blocklist`.
+       *
+       * @deprecated
+       * @hidden
+       */
+      blacklist?: string | RegExp | ((command: string) => boolean) | (string | RegExp | ((command: string) => boolean))[];
+
+      /**
+       * Whether to use a different service name for each Redis instance based
+       * on the configured connection name of the client.
+       *
+       * @default false
+       */
+      splitByInstance?: boolean;
+    }
+
     /**
      * This plugin automatically instruments the
      * [jest](https://github.com/jestjs/jest) module.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.52.0",
+  "version": "5.53.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-instrumentations/src/amqplib.js

@@ -15,13 +15,16 @@ const startCh = channel('apm:amqplib:command:start')
 const finishCh = channel('apm:amqplib:command:finish')
 const errorCh = channel('apm:amqplib:command:error')
 
-let methods = {}
+const methods = {}
 
 addHook({ name: 'amqplib', file: 'lib/defs.js', versions: [MIN_VERSION] }, defs => {
-  methods = Object.keys(defs)
-    .filter(key => Number.isInteger(defs[key]))
-    .filter(key => isCamelCase(key))
-    .reduce((acc, key) => Object.assign(acc, { [defs[key]]: kebabCase(key).replace('-', '.') }), {})
+  for (const [key, value] of Object.entries(defs)) {
+    if (Number.isInteger(value) && isCamelCase(key)) {
+      // TODO(BridgeAR): It should replace all `-` with `.`, so it has to be replaceAll or use a regex.
+      // Example method that is not renamed properly: BasicGetEmpty = 3932232
+      methods[value] = kebabCase(key).replace('-', '.')
+    }
+  }
   return defs
 })
 

package/packages/datadog-instrumentations/src/child_process.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { errorMonitor } = require('events')
 const util = require('util')
 
 const {
@@ -227,7 +228,7 @@ function wrapChildProcessAsyncMethod (ChildProcess, shell = false) {
         if (childProcess) {
           let errorExecuted = false
 
-          childProcess.on('error', (e) => {
+          childProcess.on(errorMonitor, (e) => {
             errorExecuted = true
             childProcessChannel.error.publish(e)
           })

package/packages/datadog-instrumentations/src/confluentinc-kafka-javascript.js

@@ -7,6 +7,8 @@ const {
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
+const log = require('../../dd-trace/src/log')
+
 // Create channels for Confluent Kafka JavaScript
 const channels = {
   producerStart: channel('apm:@confluentinc/kafka-javascript:produce:start'),
@@ -25,6 +27,8 @@ const channels = {
   batchConsumerCommit: channel('apm:@confluentinc/kafka-javascript:consume-batch:commit')
 }
 
+const disabledHeaderWeakSet = new WeakSet()
+
 // we need to store the offset per partition per topic for the consumer to track offsets for DSM
 const latestConsumerOffsets = new Map()
 
@@ -206,7 +210,8 @@ function instrumentKafkaJS (kafkaJS) {
                         channels.producerStart.publish({
                           topic: payload?.topic,
                           messages: payload?.messages || [],
-                          bootstrapServers: kafka._ddBrokers
+                          bootstrapServers: kafka._ddBrokers,
+                          disableHeaderInjection: disabledHeaderWeakSet.has(producer)
                         })
 
                         const result = send.apply(this, arguments)
@@ -218,6 +223,16 @@ function instrumentKafkaJS (kafkaJS) {
                           }),
                           asyncResource.bind(err => {
                             if (err) {
+                              // Fixes bug where we would inject message headers for kafka brokers
+                              // that don't support headers (version <0.11). On the error, we disable
+                              // header injection. Tnfortunately the error name / type is not more specific.
+                              // This approach is implemented by other tracers as well.
+                              if (err.name === 'KafkaJSError' && err.type === 'ERR_UNKNOWN') {
+                                disabledHeaderWeakSet.add(producer)
+                                log.error('Kafka Broker responded with UNKNOWN_SERVER_ERROR (-1). ' +
+                                  'Please look at broker logs for more information. ' +
+                                  'Tracer message header injection for Kafka is disabled.')
+                              }
                               channels.producerError.publish(err)
                             }
                             channels.producerFinish.publish(undefined)

package/packages/datadog-instrumentations/src/couchbase.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { errorMonitor } = require('events')
 const {
   channel,
   addHook,
@@ -186,7 +187,7 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
         finishCh.publish(undefined)
       }))
 
-      emitter.once('error', asyncResource.bind((error) => {
+      emitter.once(errorMonitor, asyncResource.bind((error) => {
         errorCh.publish(error)
         finishCh.publish(undefined)
       }))

package/packages/datadog-instrumentations/src/cucumber.js

@@ -8,6 +8,7 @@ const log = require('../../dd-trace/src/log')
 const testStartCh = channel('ci:cucumber:test:start')
 const testRetryCh = channel('ci:cucumber:test:retry')
 const testFinishCh = channel('ci:cucumber:test:finish') // used for test steps too
+const testFnCh = channel('ci:cucumber:test:fn')
 
 const testStepStartCh = channel('ci:cucumber:test-step:start')
 
@@ -52,7 +53,7 @@ const patched = new WeakSet()
 
 const lastStatusByPickleId = new Map()
 const numRetriesByPickleId = new Map()
-const numAttemptToAsyncResource = new Map()
+const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
 
 let eventDataCollector = null
@@ -227,16 +228,12 @@ function wrapRun (pl, isLatestVersion) {
   patched.add(pl)
 
   shimmer.wrap(pl.prototype, 'run', run => function () {
-    if (!testStartCh.hasSubscribers) {
+    if (!testFinishCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
 
     let numAttempt = 0
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    numAttemptToAsyncResource.set(numAttempt, asyncResource)
-
     const testFileAbsolutePath = this.pickle.uri
 
     const testSourceLine = this.gherkinDocument?.feature?.location?.line
@@ -247,9 +244,9 @@ function wrapRun (pl, isLatestVersion) {
       testSourceLine,
       isParallel: !!process.env.CUCUMBER_WORKER_ID
     }
-    asyncResource.runInAsyncScope(() => {
-      testStartCh.publish(testStartPayload)
-    })
+    const ctx = testStartPayload
+    numAttemptToCtx.set(numAttempt, ctx)
+    testStartCh.runStores(ctx, () => { })
     const promises = {}
     try {
       this.eventBroadcaster.on('envelope', shimmer.wrapFunction(null, () => async (testCase) => {
@@ -265,7 +262,7 @@ function wrapRun (pl, isLatestVersion) {
               // ignore error
             }
 
-            const failedAttemptAsyncResource = numAttemptToAsyncResource.get(numAttempt)
+            const failedAttemptCtx = numAttemptToCtx.get(numAttempt)
             const isFirstAttempt = numAttempt++ === 0
             const isAtrRetry = !isFirstAttempt && isFlakyTestRetriesEnabled
 
@@ -273,23 +270,19 @@ function wrapRun (pl, isLatestVersion) {
               await promises.hitBreakpointPromise
             }
 
-            failedAttemptAsyncResource.runInAsyncScope(() => {
-              // the current span will be finished and a new one will be created
-              testRetryCh.publish({ isFirstAttempt, error, isAtrRetry })
-            })
+            // the current span will be finished and a new one will be created
+            testRetryCh.publish({ isFirstAttempt, error, isAtrRetry, ...failedAttemptCtx.currentStore })
 
-            const newAsyncResource = new AsyncResource('bound-anonymous-fn')
-            numAttemptToAsyncResource.set(numAttempt, newAsyncResource)
+            const newCtx = { ...testStartPayload, promises }
+            numAttemptToCtx.set(numAttempt, newCtx)
 
-            newAsyncResource.runInAsyncScope(() => {
-              testStartCh.publish({ ...testStartPayload, promises }) // a new span will be created
-            })
+            testStartCh.runStores(newCtx, () => { })
           }
         }
       }))
       let promise
 
-      asyncResource.runInAsyncScope(() => {
+      testFnCh.runStores(ctx, () => {
         promise = run.apply(this, arguments)
       })
       promise.finally(async () => {
@@ -343,39 +336,40 @@ function wrapRun (pl, isLatestVersion) {
           isEfdRetry = numRetries > 0
         }
 
-        const attemptAsyncResource = numAttemptToAsyncResource.get(numAttempt)
+        const attemptCtx = numAttemptToCtx.get(numAttempt)
 
         const error = getErrorFromCucumberResult(result)
 
         if (promises.hitBreakpointPromise) {
           await promises.hitBreakpointPromise
         }
-        attemptAsyncResource.runInAsyncScope(() => {
-          testFinishCh.publish({
-            status,
-            skipReason,
-            error,
-            isNew,
-            isEfdRetry,
-            isFlakyRetry: numAttempt > 0,
-            isAttemptToFix,
-            isAttemptToFixRetry,
-            hasFailedAllRetries,
-            hasPassedAllRetries,
-            hasFailedAttemptToFix,
-            isDisabled,
-            isQuarantined
-          })
+        testFinishCh.publish({
+          status,
+          skipReason,
+          error,
+          isNew,
+          isEfdRetry,
+          isFlakyRetry: numAttempt > 0,
+          isAttemptToFix,
+          isAttemptToFixRetry,
+          hasFailedAllRetries,
+          hasPassedAllRetries,
+          hasFailedAttemptToFix,
+          isDisabled,
+          isQuarantined,
+          ...attemptCtx.currentStore
         })
       })
       return promise
     } catch (err) {
-      errorCh.publish(err)
-      throw err
+      ctx.err = err
+      errorCh.runStores(ctx, () => {
+        throw err
+      })
     }
   })
   shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
-    if (!testStepStartCh.hasSubscribers) {
+    if (!testFinishCh.hasSubscribers) {
       return runStep.apply(this, arguments)
     }
     const testStep = arguments[0]
@@ -387,9 +381,8 @@ function wrapRun (pl, isLatestVersion) {
       resource = testStep.isHook ? 'hook' : testStep.pickleStep.text
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      testStepStartCh.publish({ resource })
+    const ctx = { resource }
+    return testStepStartCh.runStores(ctx, () => {
       try {
         const promise = runStep.apply(this, arguments)
 
@@ -398,12 +391,14 @@ function wrapRun (pl, isLatestVersion) {
             ? getStatusFromResultLatest(result)
             : getStatusFromResult(result)
 
-          testFinishCh.publish({ isStep: true, status, skipReason, errorMessage })
+          testFinishCh.publish({ isStep: true, status, skipReason, errorMessage, ...ctx.currentStore })
         })
         return promise
       } catch (err) {
-        errorCh.publish(err)
-        throw err
+        ctx.err = err
+        errorCh.runStores(ctx, () => {
+          throw err
+        })
       }
     })
   })

package/packages/datadog-instrumentations/src/express.js

@@ -149,11 +149,9 @@ addHook({ name: 'express', versions: ['>=4.3.0 <5.0.0'] }, express => {
 const queryReadCh = channel('datadog:express:query:finish')
 
 addHook({ name: 'express', file: ['lib/request.js'], versions: ['>=5.0.0'] }, request => {
-  const requestDescriptor = Object.getOwnPropertyDescriptor(request, 'query')
-
-  shimmer.wrap(requestDescriptor, 'get', function (originalGet) {
+  shimmer.wrap(request, 'query', function (originalGet) {
     return function wrappedGet () {
-      const query = originalGet.apply(this, arguments)
+      const query = originalGet.call(this)
 
       if (queryReadCh.hasSubscribers && query) {
         queryReadCh.publish({ query })
@@ -163,7 +161,5 @@ addHook({ name: 'express', file: ['lib/request.js'], versions: ['>=5.0.0'] }, re
     }
   })
 
-  Object.defineProperty(request, 'query', requestDescriptor)
-
   return request
 })

package/packages/datadog-instrumentations/src/fs.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { errorMonitor } = require('events')
 const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -199,16 +200,16 @@ function wrapCreateStream (original) {
         }
         const onFinish = () => {
           finishChannel.runStores(ctx, () => {})
-          stream.off('close', onFinish)
-          stream.off('end', onFinish)
-          stream.off('finish', onFinish)
-          stream.off('error', onError)
+          stream.removeListener('close', onFinish)
+          stream.removeListener('end', onFinish)
+          stream.removeListener('finish', onFinish)
+          stream.removeListener(errorMonitor, onError)
         }
 
         stream.once('close', onFinish)
         stream.once('end', onFinish)
         stream.once('finish', onFinish)
-        stream.once('error', onError)
+        stream.once(errorMonitor, onError)
 
         return stream
       } catch (error) {

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -61,6 +61,7 @@ module.exports = {
   http2: () => require('../http2'),
   https: () => require('../http'),
   ioredis: () => require('../ioredis'),
+  iovalkey: () => require('../iovalkey'),
   'jest-circus': () => require('../jest'),
   'jest-config': () => require('../jest'),
   'jest-environment-node': () => require('../jest'),

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -43,7 +43,7 @@ if (!disabledInstrumentations.has('process')) {
   require('../process')
 }
 
-const HOOK_SYMBOL = Symbol('hookExportsMap')
+const HOOK_SYMBOL = Symbol('hookExportsSet')
 
 if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
   checkRequireCache.checkForRequiredModules()
@@ -89,12 +89,13 @@ for (const packageName of names) {
         fullFilePattern = filename(name, fullFilePattern)
       }
 
-      // Create a WeakMap associated with the hook function so that patches on the same moduleExport only happens once
+      // Create a WeakSet associated with the hook function so that patches on the same moduleExport only happens once
       // for example by instrumenting both dns and node:dns double the spans would be created
-      // since they both patch the same moduleExport, this WeakMap is used to mitigate that
-      if (!hook[HOOK_SYMBOL]) {
-        hook[HOOK_SYMBOL] = new WeakMap()
-      }
+      // since they both patch the same moduleExport, this WeakSet is used to mitigate that
+      // TODO(BridgeAR): Instead of using a WeakSet here, why not just use aliases for the hook in register?
+      // That way it would also not be duplicated. The actual name being used has to be identified else wise.
+      // Maybe it is also not important to know what name was actually used?
+      hook[HOOK_SYMBOL] ??= new WeakSet()
       let matchesFile = false
 
       matchesFile = moduleName === fullFilename
@@ -114,7 +115,7 @@ for (const packageName of names) {
           log.error('Error getting version for "%s": %s', name, e.message, e)
           continue
         }
-        if (typeof namesAndSuccesses[`${name}@${version}`] === 'undefined') {
+        if (namesAndSuccesses[`${name}@${version}`] === undefined) {
           // TODO If `file` is present, we might elsewhere instrument the result of the module
           // for a version range that actually matches, so we can't assume that we're _not_
           // going to instrument that. However, the way the data model around instrumentation
@@ -140,12 +141,16 @@ for (const packageName of names) {
             loadChannel.publish({ name, version, file })
             // Send the name and version of the module back to the callback because now addHook
             // takes in an array of names so by passing the name the callback will know which module name is being used
-            moduleExports = hook(moduleExports, version, name)
-            // Set the moduleExports in the hooks weakmap
-            hook[HOOK_SYMBOL].set(moduleExports, name)
+            // TODO(BridgeAR): This is only true in case the name is identical
+            // in all loads. If they deviate, the deviating name would not be
+            // picked up due to the unification. Check what modules actually use the name.
+            // TODO(BridgeAR): Only replace moduleExports if the hook returns a new value.
+            // This allows to reduce the instrumentation code (no return needed).
+            moduleExports = hook(moduleExports, version, name) ?? moduleExports
+            // Set the moduleExports in the hooks WeakSet
+            hook[HOOK_SYMBOL].add(moduleExports)
           } catch (e) {
-            log.info('Error during ddtrace instrumentation of application, aborting.')
-            log.info(e)
+            log.info('Error during ddtrace instrumentation of application, aborting.', e)
             telemetry('error', [
               `error_type:${e.constructor.name}`,
               `integration:${name}`,

package/packages/datadog-instrumentations/src/http/client.js

@@ -3,6 +3,7 @@
 /* eslint-disable no-fallthrough */
 
 const url = require('url')
+const { errorMonitor } = require('events')
 const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
@@ -88,7 +89,7 @@ function patch (http, methodName) {
                 const res = arg
                 ctx.res = res
                 res.on('end', finish)
-                res.on('error', finish)
+                res.on(errorMonitor, finish)
                 break
               }
               case 'connect':

package/packages/datadog-instrumentations/src/iovalkey.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:iovalkey:command:start')
+const finishCh = channel('apm:iovalkey:command:finish')
+const errorCh = channel('apm:iovalkey:command:error')
+
+addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
+  shimmer.wrap(Valkey.prototype, 'sendCommand', sendCommand => function (command, stream) {
+    if (!startCh.hasSubscribers) return sendCommand.apply(this, arguments)
+
+    if (!command?.promise) return sendCommand.apply(this, arguments)
+
+    const options = this.options || {}
+    const connectionName = options.connectionName
+    const db = options.db
+    const connectionOptions = { host: options.host, port: options.port }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
+
+      const onResolve = asyncResource.bind(() => finishCh.publish())
+      const onReject = asyncResource.bind(err => finish(finishCh, errorCh, err))
+
+      command.promise.then(onResolve, onReject)
+
+      try {
+        return sendCommand.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
+
+        throw err
+      }
+    })
+  })
+  return Valkey
+})
+
+function finish (finishCh, errorCh, error) {
+  if (error) {
+    errorCh.publish(error)
+  }
+  finishCh.publish()
+}