dd-trace 5.53.0 → 5.54.0

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

@@ -15,7 +15,9 @@ const {
   getIsFaultyEarlyFlakeDetection,
   JEST_WORKER_LOGS_PAYLOAD_CODE,
   addAttemptToFixStringToTestName,
-  removeAttemptToFixStringFromTestName
+  removeAttemptToFixStringFromTestName,
+  getTestEndLine,
+  isModifiedTest
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   getFormattedJestTestParameters,
@@ -47,6 +49,7 @@ const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const libraryConfigurationCh = channel('ci:jest:library-configuration')
 const knownTestsCh = channel('ci:jest:known-tests')
 const testManagementTestsCh = channel('ci:jest:test-management-tests')
+const impactedTestsCh = channel('ci:jest:modified-tests')
 
 const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 
@@ -54,8 +57,8 @@ const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 // https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/types.ts#L37
 const CHILD_MESSAGE_CALL = 1
 // Maximum time we'll wait for the tracer to flush
-const FLUSH_TIMEOUT = 10000
-// eslint-disable-next-line
+const FLUSH_TIMEOUT = 10_000
+
 // https://github.com/jestjs/jest/blob/41f842a46bb2691f828c3a5f27fc1d6290495b82/packages/jest-circus/src/types.ts#L9C8-L9C54
 const RETRY_TIMES = Symbol.for('RETRY_TIMES')
 
@@ -77,6 +80,8 @@ let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
 let testManagementTests = {}
 let testManagementAttemptToFixRetries = 0
+let isImpactedTestsEnabled = false
+let modifiedTests = {}
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -150,6 +155,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.isDiEnabled = this.testEnvironmentOptions._ddIsDiEnabled
       this.isKnownTestsEnabled = this.testEnvironmentOptions._ddIsKnownTestsEnabled
       this.isTestManagementTestsEnabled = this.testEnvironmentOptions._ddIsTestManagementTestsEnabled
+      this.isImpactedTestsEnabled = this.testEnvironmentOptions._ddIsImpactedTestsEnabled
 
       if (this.isKnownTestsEnabled) {
         try {
@@ -158,7 +164,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           this.knownTestsForThisSuite = hasKnownTests
             ? (knownTests?.jest?.[this.testSuite] || [])
             : this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
-        } catch (e) {
+        } catch {
           // If there has been an error parsing the tests, we'll disable Early Flake Deteciton
           this.isEarlyFlakeDetectionEnabled = false
           this.isKnownTestsEnabled = false
@@ -184,6 +190,18 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           this.isTestManagementTestsEnabled = false
         }
       }
+
+      if (this.isImpactedTestsEnabled) {
+        try {
+          const hasImpactedTests = Object.keys(modifiedTests).length > 0
+          this.modifiedTestsForThisSuite = hasImpactedTests
+            ? this.getModifiedTestForThisSuite(modifiedTests)
+            : this.getModifiedTestForThisSuite(this.testEnvironmentOptions._ddModifiedTests)
+        } catch (e) {
+          log.error('Error parsing impacted tests', e)
+          this.isImpactedTestsEnabled = false
+        }
+      }
     }
 
     getHasSnapshotTests () {
@@ -194,7 +212,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       try {
         const { _snapshotData } = this.getVmContext().expect.getState().snapshotState
         hasSnapshotTests = Object.keys(_snapshotData).length > 0
-      } catch (e) {
+      } catch {
         // if we can't be sure, we'll err on the side of caution and assume it has snapshots
       }
       this.hasSnapshotTests = hasSnapshotTests
@@ -255,6 +273,19 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       return result
     }
 
+    getModifiedTestForThisSuite (modifiedTests) {
+      if (this.modifiedTestsForThisSuite) {
+        return this.modifiedTestsForThisSuite
+      }
+      let modifiedTestsForThisSuite = modifiedTests
+      // If jest is using workers, modified tests are serialized to json.
+      // If jest runs in band, they are not.
+      if (typeof modifiedTestsForThisSuite === 'string') {
+        modifiedTestsForThisSuite = JSON.parse(modifiedTestsForThisSuite)
+      }
+      return modifiedTestsForThisSuite
+    }
+
     // Generic function to handle test retries
     retryTest (testName, retryCount, addRetryStringToTestName, retryType, event) {
       // Retrying snapshots has proven to be problematic, so we'll skip them for now
@@ -288,18 +319,16 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
       const setNameToParams = (name, params) => { this.nameToParams[name] = [...params] }
 
-      if (event.name === 'setup') {
-        if (this.global.test) {
-          shimmer.wrap(this.global.test, 'each', each => function () {
-            const testParameters = getFormattedJestTestParameters(arguments)
-            const eachBind = each.apply(this, arguments)
-            return function () {
-              const [testName] = arguments
-              setNameToParams(testName, testParameters)
-              return eachBind.apply(this, arguments)
-            }
-          })
-        }
+      if (event.name === 'setup' && this.global.test) {
+        shimmer.wrap(this.global.test, 'each', each => function () {
+          const testParameters = getFormattedJestTestParameters(arguments)
+          const eachBind = each.apply(this, arguments)
+          return function () {
+            const [testName] = arguments
+            setNameToParams(testName, testParameters)
+            return eachBind.apply(this, arguments)
+          }
+        })
       }
       if (event.name === 'test_start') {
         let isNewTest = false
@@ -326,12 +355,26 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
 
+        let isModified = false
+        if (this.isImpactedTestsEnabled) {
+          const testStartLine = getTestLineStart(event.test.asyncError, this.testSuite)
+          const testEndLine = getTestEndLine(event.test.fn, testStartLine)
+          isModified = isModifiedTest(
+            this.testSourceFile,
+            testStartLine,
+            testEndLine,
+            this.modifiedTestsForThisSuite,
+            'jest'
+          )
+        }
+
         if (this.isKnownTestsEnabled) {
           isNewTest = retriedTestsToNumAttempts.has(originalTestName)
-          if (isNewTest) {
-            numEfdRetry = retriedTestsToNumAttempts.get(originalTestName)
-            retriedTestsToNumAttempts.set(originalTestName, numEfdRetry + 1)
-          }
+        }
+
+        if (this.isEarlyFlakeDetectionEnabled && (isNewTest || isModified)) {
+          numEfdRetry = retriedTestsToNumAttempts.get(originalTestName)
+          retriedTestsToNumAttempts.set(originalTestName, numEfdRetry + 1)
         }
 
         const isJestRetry = event.test?.invocations > 1
@@ -348,22 +391,25 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           isAttemptToFixRetry: numOfAttemptsToFixRetries > 0,
           isJestRetry,
           isDisabled,
-          isQuarantined
+          isQuarantined,
+          isModified
         }
         testContexts.set(event.test, ctx)
 
         testStartCh.runStores(ctx, () => {
           for (const hook of event.test.parent.hooks) {
             let hookFn = hook.fn
-            if (!originalHookFns.has(hook)) {
-              originalHookFns.set(hook, hookFn)
-            } else {
+            if (originalHookFns.has(hook)) {
               hookFn = originalHookFns.get(hook)
+            } else {
+              originalHookFns.set(hook, hookFn)
             }
+            // The rule has a bug, see https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2164
+            // eslint-disable-next-line unicorn/consistent-function-scoping
             const wrapperHook = function () {
               return testFnCh.runStores(ctx, () => hookFn.apply(this, arguments))
             }
-            // If we don't do this, the timeout will be not be triggered
+            // If we don't do this, the timeout will not be triggered
             Object.defineProperty(wrapperHook, 'length', { value: hookFn.length })
             hook.fn = wrapperHook
           }
@@ -395,6 +441,27 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             )
           }
         }
+        if (this.isImpactedTestsEnabled) {
+          const testStartLine = getTestLineStart(event.asyncError, this.testSuite)
+          const testEndLine = getTestEndLine(event.fn, testStartLine)
+          const isModified = isModifiedTest(
+            this.testSourceFile,
+            testStartLine,
+            testEndLine,
+            this.modifiedTestsForThisSuite,
+            'jest'
+          )
+          if (isModified && !retriedTestsToNumAttempts.has(originalTestName) && this.isEarlyFlakeDetectionEnabled) {
+            retriedTestsToNumAttempts.set(originalTestName, 0)
+            this.retryTest(
+              event.testName,
+              earlyFlakeDetectionNumRetries,
+              addEfdStringToTestName,
+              'Early flake detection',
+              event
+            )
+          }
+        }
         if (this.isKnownTestsEnabled) {
           const isNew = !this.knownTestsForThisSuite?.includes(originalTestName)
           if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(originalTestName)) {
@@ -438,7 +505,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             // If it is, we'll set the failedAllTests flag to true if all the tests failed
             // If all tests passed, we'll set the attemptToFixPassed flag to true
             if (testStatuses.length === testManagementAttemptToFixRetries + 1) {
-              if (testStatuses.some(status => status === 'fail')) {
+              if (testStatuses.includes('fail')) {
                 attemptToFixFailed = true
               }
               if (testStatuses.every(status => status === 'fail')) {
@@ -659,6 +726,7 @@ function cliWrapper (cli, jestVersion) {
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
         isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
         testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
+        isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
       }
     } catch (err) {
       log.error('Jest library configuration error', err)
@@ -675,12 +743,12 @@ function cliWrapper (cli, jestVersion) {
 
       try {
         const { err, knownTests: receivedKnownTests } = await knownTestsPromise
-        if (!err) {
-          knownTests = receivedKnownTests
-        } else {
+        if (err) {
           // We disable EFD if there has been an error in the known tests request
           isEarlyFlakeDetectionEnabled = false
           isKnownTestsEnabled = false
+        } else {
+          knownTests = receivedKnownTests
         }
       } catch (err) {
         log.error('Jest known tests error', err)
@@ -725,6 +793,25 @@ function cliWrapper (cli, jestVersion) {
       }
     }
 
+    if (isImpactedTestsEnabled) {
+      const impactedTestsPromise = new Promise((resolve) => {
+        onDone = resolve
+      })
+
+      sessionAsyncResource.runInAsyncScope(() => {
+        impactedTestsCh.publish({ onDone })
+      })
+
+      try {
+        const { err, modifiedTests: receivedModifiedTests } = await impactedTestsPromise
+        if (!err) {
+          modifiedTests = receivedModifiedTests
+        }
+      } catch (err) {
+        log.error('Jest impacted tests error', err)
+      }
+    }
+
     const processArgv = process.argv.slice(2).join(' ')
     sessionAsyncResource.runInAsyncScope(() => {
       testSessionStartCh.publish({ command: `jest ${processArgv}`, frameworkVersion: jestVersion })
@@ -748,19 +835,15 @@ function cliWrapper (cli, jestVersion) {
     if (isUserCodeCoverageEnabled) {
       try {
         const { pct, total } = coverageMap.getCoverageSummary().lines
-        testCodeCoverageLinesTotal = total !== 0 ? pct : 0
-      } catch (e) {
+        testCodeCoverageLinesTotal = total === 0 ? 0 : pct
+      } catch {
         // ignore errors
       }
     }
     let status, error
 
     if (success) {
-      if (numTotalTests === 0 && numTotalTestSuites === 0) {
-        status = 'skip'
-      } else {
-        status = 'pass'
-      }
+      status = numTotalTests === 0 && numTotalTestSuites === 0 ? 'skip' : 'pass'
     } else {
       status = 'fail'
       error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
@@ -878,7 +961,7 @@ function cliWrapper (cli, jestVersion) {
 }
 
 function coverageReporterWrapper (coverageReporter) {
-  const CoverageReporter = coverageReporter.default ? coverageReporter.default : coverageReporter
+  const CoverageReporter = coverageReporter.default ?? coverageReporter
 
   /**
    * If ITR is active, we're running fewer tests, so of course the total code coverage is reduced.
@@ -917,7 +1000,7 @@ addHook({
 }, cliWrapper)
 
 function jestAdapterWrapper (jestAdapter, jestVersion) {
-  const adapter = jestAdapter.default ? jestAdapter.default : jestAdapter
+  const adapter = jestAdapter.default ?? jestAdapter
   const newAdapter = shimmer.wrapFunction(adapter, adapter => function () {
     const environment = arguments[2]
     if (!environment) {
@@ -1065,6 +1148,7 @@ addHook({
       _ddIsTestManagementTestsEnabled,
       _ddTestManagementTests,
       _ddTestManagementAttemptToFixRetries,
+      _ddModifiedTests,
       ...restOfTestEnvironmentOptions
     } = testEnvironmentOptions
 
@@ -1086,7 +1170,7 @@ addHook({
   versions: ['>=24.8.0'],
   file: 'build/SearchSource.js'
 }, (searchSourcePackage, frameworkVersion) => {
-  const SearchSource = searchSourcePackage.default ? searchSourcePackage.default : searchSourcePackage
+  const SearchSource = searchSourcePackage.default ?? searchSourcePackage
 
   shimmer.wrap(SearchSource.prototype, 'getTestPaths', getTestPaths => async function () {
     const testPaths = await getTestPaths.apply(this, arguments)
@@ -1140,7 +1224,7 @@ addHook({
   versions: ['24.8.0 - 24.9.0']
 }, jestConfigSyncWrapper)
 
-const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = [
+const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
   'selenium-webdriver',
   'selenium-webdriver/chrome',
   'selenium-webdriver/edge',
@@ -1149,11 +1233,11 @@ const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = [
   'selenium-webdriver/ie',
   'selenium-webdriver/chromium',
   'winston'
-]
+])
 
 function shouldBypassJestRequireEngine (moduleName) {
   return (
-    LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.includes(moduleName)
+    LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)
   )
 }
 
@@ -1161,7 +1245,7 @@ addHook({
   name: 'jest-runtime',
   versions: ['>=24.8.0']
 }, (runtimePackage) => {
-  const Runtime = runtimePackage.default ? runtimePackage.default : runtimePackage
+  const Runtime = runtimePackage.default ?? runtimePackage
 
   shimmer.wrap(Runtime.prototype, 'requireModuleOrMock', requireModuleOrMock => function (from, moduleName) {
     // TODO: do this for every library that we instrument
@@ -1188,17 +1272,17 @@ addHook({
 }, (childProcessWorker) => {
   const ChildProcessWorker = childProcessWorker.default
   shimmer.wrap(ChildProcessWorker.prototype, 'send', send => function (request) {
-    if (!isKnownTestsEnabled && !isTestManagementTestsEnabled) {
+    if (!isKnownTestsEnabled && !isTestManagementTestsEnabled && !isImpactedTestsEnabled) {
       return send.apply(this, arguments)
     }
     const [type] = request
-    // eslint-disable-next-line
+
     // https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/workers/ChildProcessWorker.ts#L424
     if (type === CHILD_MESSAGE_CALL) {
       // This is the message that the main process sends to the worker to run a test suite (=test file).
       // In here we modify the config.testEnvironmentOptions to include the known tests for the suite.
       // This way the suite only knows about the tests that are part of it.
-      const args = request[request.length - 1]
+      const args = request.at(-1)
       if (args.length > 1) {
         return send.apply(this, arguments)
       }
@@ -1211,12 +1295,17 @@ addHook({
 
       const suiteTestManagementTests = testManagementTests?.jest?.suites?.[testSuite]?.tests || {}
 
+      const suiteModifiedTests = Object.keys(modifiedTests).length > 0
+        ? modifiedTests
+        : {}
+
       args[0].config = {
         ...config,
         testEnvironmentOptions: {
           ...config.testEnvironmentOptions,
           _ddKnownTests: suiteKnownTests,
-          _ddTestManagementTests: suiteTestManagementTests
+          _ddTestManagementTests: suiteTestManagementTests,
+          _ddModifiedTests: suiteModifiedTests
         }
       }
     }

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -60,33 +59,37 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
 
     producer.send = function () {
       const wrappedSend = (clusterId) => {
-        const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
+        const { topic, messages = [] } = arguments[0]
+
+        const ctx = {
+          bootstrapServers,
+          clusterId,
+          disableHeaderInjection: disabledHeaderWeakSet.has(producer),
+          messages,
+          topic
+        }
 
-        return innerAsyncResource.runInAsyncScope(() => {
-          if (!producerStartCh.hasSubscribers) {
-            return send.apply(this, arguments)
+        for (const message of messages) {
+          if (message !== null && typeof message === 'object' && !ctx.disableHeaderInjection) {
+            message.headers = message.headers || {}
           }
+        }
 
+        return producerStartCh.runStores(ctx, () => {
           try {
-            const { topic, messages = [] } = arguments[0]
-            producerStartCh.publish({
-              topic,
-              messages,
-              bootstrapServers,
-              clusterId,
-              disableHeaderInjection: disabledHeaderWeakSet.has(producer)
-            })
             const result = send.apply(this, arguments)
             result.then(
-              innerAsyncResource.bind(res => {
-                producerFinishCh.publish(undefined)
-                producerCommitCh.publish(res)
-              }),
-              innerAsyncResource.bind(err => {
+              (res) => {
+                ctx.result = res
+                producerFinishCh.publish(ctx)
+                producerCommitCh.publish(ctx)
+              },
+              (err) => {
+                ctx.error = 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.
+                  // Unfortunately the error name / type is not more specific.
                   // This approach is implemented by other tracers as well.
                   if (err.name === 'KafkaJSProtocolError' && err.type === 'UNKNOWN') {
                     disabledHeaderWeakSet.add(producer)
@@ -96,28 +99,28 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
                   }
                   producerErrorCh.publish(err)
                 }
-                producerFinishCh.publish(undefined)
+                producerFinishCh.publish(ctx)
               })
-            )
 
             return result
           } catch (e) {
-            producerErrorCh.publish(e)
-            producerFinishCh.publish(undefined)
+            ctx.error = e
+            producerErrorCh.publish(ctx)
+            producerFinishCh.publish(ctx)
             throw e
           }
         })
       }
 
-      if (!isPromise(kafkaClusterIdPromise)) {
-        // promise is already resolved
-        return wrappedSend(kafkaClusterIdPromise)
-      } else {
+      if (isPromise(kafkaClusterIdPromise)) {
         // promise is not resolved
         return kafkaClusterIdPromise.then((clusterId) => {
           return wrappedSend(clusterId)
         })
       }
+
+      // promise is already resolved
+      return wrappedSend(kafkaClusterIdPromise)
     }
     return producer
   })
@@ -170,15 +173,15 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
         })
       }
 
-      if (!isPromise(kafkaClusterIdPromise)) {
-        // promise is already resolved
-        return wrapConsume(kafkaClusterIdPromise)
-      } else {
+      if (isPromise(kafkaClusterIdPromise)) {
         // promise is not resolved
         return kafkaClusterIdPromise.then((clusterId) => {
           return wrapConsume(clusterId)
         })
       }
+
+      // promise is already resolved
+      return wrapConsume(kafkaClusterIdPromise)
     }
     return consumer
   })
@@ -188,30 +191,35 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
 const wrappedCallback = (fn, startCh, finishCh, errorCh, extractArgs, clusterId) => {
   return typeof fn === 'function'
     ? function (...args) {
-      const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
-      return innerAsyncResource.runInAsyncScope(() => {
-        const extractedArgs = extractArgs(args, clusterId)
+      const extractedArgs = extractArgs(args, clusterId)
+      const ctx = {
+        extractedArgs
+      }
 
-        startCh.publish(extractedArgs)
+      return startCh.runStores(ctx, () => {
         try {
           const result = fn.apply(this, args)
           if (result && typeof result.then === 'function') {
             result.then(
-              innerAsyncResource.bind(() => finishCh.publish(undefined)),
-              innerAsyncResource.bind(err => {
+              (res) => {
+                ctx.result = res
+                finishCh.publish(ctx)
+              },
+              (err) => {
+                ctx.error = err
                 if (err) {
-                  errorCh.publish(err)
+                  errorCh.publish(ctx)
                 }
-                finishCh.publish(undefined)
+                finishCh.publish(ctx)
               })
-            )
           } else {
-            finishCh.publish(undefined)
+            finishCh.publish(ctx)
           }
           return result
         } catch (e) {
-          errorCh.publish(e)
-          finishCh.publish(undefined)
+          ctx.error = e
+          errorCh.publish(ctx)
+          finishCh.publish(ctx)
           throw e
         }
       })

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

@@ -22,6 +22,10 @@ function patch (file) {
   })
 }
 
+function finish () {
+  finishRawQueryCh.publish()
+}
+
 addHook({
   name: 'knex',
   versions: ['>=2'],
@@ -41,10 +45,6 @@ addHook({
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-    function finish () {
-      finishRawQueryCh.publish()
-    }
-
     return asyncResource.runInAsyncScope(() => {
       startRawQueryCh.publish({ sql, dialect: this.dialect })
 

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

@@ -8,6 +8,7 @@ const {
 const shimmer = require('../../datadog-shimmer')
 
 function isString (value) {
+  // eslint-disable-next-line unicorn/no-instanceof-builtins
   return typeof value === 'string' || value instanceof String
 }
 
@@ -61,10 +62,8 @@ addHook({ name: 'ldapjs', versions: ['>=2'] }, ldapjs => {
       let filter
       if (isString(options)) {
         filter = options
-      } else if (options !== null && typeof options === 'object' && options.filter) {
-        if (isString(options.filter)) {
-          filter = options.filter
-        }
+      } else if (options !== null && typeof options === 'object' && options.filter && isString(options.filter)) {
+        filter = options.filter
       }
       ldapSearchCh.publish({ base, filter })
     }