Clean up tests

Author: watson

packages/dd-trace/test/config.spec.js

@@ -3489,59 +3489,104 @@ rules:
   describe('remote config field mapping', () => {
     it('should map dynamic_instrumentation_enabled to dynamicInstrumentation.enabled', () => {
       const config = getConfig()
+      assert.strictEqual(config.dynamicInstrumentation.enabled, false)
       config.setRemoteConfig({ dynamic_instrumentation_enabled: true })
       assert.strictEqual(config.dynamicInstrumentation.enabled, true)
     })
 
     it('should map code_origin_enabled to codeOriginForSpans.enabled', () => {
       const config = getConfig()
-      config.setRemoteConfig({ code_origin_enabled: true })
       assert.strictEqual(config.codeOriginForSpans.enabled, true)
+      config.setRemoteConfig({ code_origin_enabled: false })
+      assert.strictEqual(config.codeOriginForSpans.enabled, false)
     })
 
-    it('should handle false values correctly', () => {
+    it('should map tracing_sampling_rate to sampleRate', () => {
       const config = getConfig()
-      config.setRemoteConfig({ dynamic_instrumentation_enabled: false })
-      assert.strictEqual(config.dynamicInstrumentation.enabled, false)
+      assert.strictEqual(config.sampleRate, undefined)
+      config.setRemoteConfig({ tracing_sampling_rate: 0.5 })
+      assert.strictEqual(config.sampleRate, 0.5)
+    })
+
+    it('should map log_injection_enabled to logInjection', () => {
+      const config = getConfig()
+      assert.strictEqual(config.logInjection, true)
+      config.setRemoteConfig({ log_injection_enabled: false })
+      assert.strictEqual(config.logInjection, false)
+    })
+
+    it('should map tracing_enabled to tracing', () => {
+      const config = getConfig()
+      assert.strictEqual(config.tracing, true)
+      config.setRemoteConfig({ tracing_enabled: false })
+      assert.strictEqual(config.tracing, false)
+    })
+
+    it('should map tracing_sampling_rules to sampler.rules', () => {
+      const config = getConfig()
+      assert.deepStrictEqual(config.sampler.rules, [])
+      config.setRemoteConfig({ tracing_sampling_rules: [{ sample_rate: 0.5 }] })
+      assert.deepStrictEqual(config.sampler.rules, [{ sampleRate: 0.5 }])
+    })
+
+    it('should map tracing_header_tags to headerTags', () => {
+      const config = getConfig({ headerTags: ['foo:bar'] })
+      assert.deepStrictEqual(config.headerTags, ['foo:bar'])
+      config.setRemoteConfig({ tracing_header_tags: [{ header: 'x-custom-header', tag_name: 'custom.tag' }] })
+      assert.deepStrictEqual(config.headerTags, [
+        // TODO: There's an unrelated bug in the tracer resulting in headerTags not being merged.
+        // 'foo:bar',
+        'x-custom-header:custom.tag'
+      ])
+    })
+
+    it('should map tracing_tags to tags', () => {
+      const config = getConfig({ tags: { foo: 'bar' } })
+      assertObjectContains(config.tags, { foo: 'bar' })
+      assert.strictEqual(config.tags.team, undefined)
+      config.setRemoteConfig({ tracing_tags: ['team:backend'] })
+      assertObjectContains(config.tags, {
+        // TODO: There's an unrelated bug in the tracer resulting in tags not being merged.
+        // foo: 'bar',
+        team: 'backend'
+      })
     })
   })
 
   describe('remote config application', () => {
     it('should clear RC fields when setRemoteConfig is called with null', () => {
       const config = getConfig({ logInjection: true, sampleRate: 0.5 })
 
-      // Apply remote config with tracing_enabled set to false (different from default)
       config.setRemoteConfig({ tracing_enabled: false })
 
-      // RC sets tracing to false, but logInjection and sampleRate come from env/options
       assert.strictEqual(config.tracing, false)
       assert.strictEqual(config.logInjection, true)
       assert.strictEqual(config.sampleRate, 0.5)
 
-      // Now clear remote config (all configs removed)
       config.setRemoteConfig(null)
 
-      // All RC values should be cleared, falling back to env/options/defaults
-      assert.strictEqual(config.tracing, true) // Falls back to default (true)
+      assert.strictEqual(config.tracing, true)
       assert.strictEqual(config.logInjection, true)
       assert.strictEqual(config.sampleRate, 0.5)
     })
 
-    it('should treat null values as unset', () => {
+    it('should ignore null values', () => {
       const config = getConfig({ sampleRate: 0.5 })
-
-      // Apply remote config with null value (field is present but null)
-      // Null should be treated as "unset" and not override the env/options value
       config.setRemoteConfig({ tracing_sampling_rate: null })
+      assert.strictEqual(config.sampleRate, 0.5)
+    })
 
-      // Null values should result in undefined, falling back to env value
+    it('should treat null values as unset', () => {
+      const config = getConfig({ sampleRate: 0.5 })
+      config.setRemoteConfig({ tracing_sampling_rate: 0.8 })
+      assert.strictEqual(config.sampleRate, 0.8)
+      config.setRemoteConfig({ tracing_sampling_rate: null })
       assert.strictEqual(config.sampleRate, 0.5)
     })
 
     it('should replace all RC fields with each update', () => {
       const config = getConfig()
 
-      // First apply a remote config with multiple fields
       config.setRemoteConfig({
         tracing_enabled: true,
         log_injection_enabled: false,
@@ -3552,111 +3597,13 @@ rules:
       assert.strictEqual(config.logInjection, false)
       assert.strictEqual(config.sampleRate, 0.8)
 
-      // Then apply a new merged config with only tracing_enabled
-      // This represents the complete merged config after multiconfig processing
       config.setRemoteConfig({
         tracing_enabled: false
       })
 
-      // Only tracing_enabled is set by RC now, others fall back to defaults
       assert.strictEqual(config.tracing, false)
-      assert.strictEqual(config.logInjection, true) // Falls back to default (true)
-      assert.strictEqual(config.sampleRate, undefined) // Falls back to default (undefined)
-    })
-
-    it('should clear tracing_header_tags when not in merged config', () => {
-      const config = getConfig({
-        headerTags: ['x-custom-header:custom.tag']
-      })
-
-      // Apply remote config with tracing_header_tags
-      config.setRemoteConfig({
-        tracing_header_tags: [
-          { header: 'x-rc-header', tag_name: 'rc.tag' }
-        ]
-      })
-
-      // RC value should override
-      assert.deepStrictEqual(config.headerTags, ['x-rc-header:rc.tag'])
-
-      // Apply remote config without tracing_header_tags
-      config.setRemoteConfig({ tracing_enabled: true })
-
-      // RC no longer sets headerTags, falls back to env/options
-      assert.deepStrictEqual(config.headerTags, ['x-custom-header:custom.tag'])
-    })
-
-    it('should process tracing_header_tags when present', () => {
-      const config = getConfig({
-        headerTags: ['x-custom-header:custom.tag']
-      })
-
-      // Apply remote config with tracing_header_tags
-      config.setRemoteConfig({
-        tracing_header_tags: [
-          { header: 'x-new-header', tag_name: 'new.tag' }
-        ]
-      })
-
-      // headerTags should be updated
-      assert.deepStrictEqual(config.headerTags, ['x-new-header:new.tag'])
-    })
-
-    it('should clear tracing_tags when not in merged config', () => {
-      const config = getConfig({
-        tags: { env: 'production', version: '1.0.0' }
-      })
-
-      // Apply remote config with tracing_tags
-      config.setRemoteConfig({
-        tracing_tags: ['team:backend']
-      })
-
-      // RC tags should override
-      assert.strictEqual(config.tags.team, 'backend')
-      assert.strictEqual(config.tags.env, undefined) // RC doesn't include env
-
-      // Apply remote config without tracing_tags
-      config.setRemoteConfig({ tracing_enabled: true })
-
-      // RC no longer sets tags, falls back to env/options
-      assert.strictEqual(config.tags.env, 'production')
-      assert.strictEqual(config.tags.version, '1.0.0')
-      assert.strictEqual(config.tags.team, undefined)
-    })
-
-    it('should process tracing_tags when present', () => {
-      const config = getConfig({
-        tags: { env: 'production' }
-      })
-
-      // Apply remote config with tracing_tags
-      config.setRemoteConfig({
-        tracing_tags: ['team:backend', 'region:us-east']
-      })
-
-      // Tags should be updated
-      assert.strictEqual(config.tags.team, 'backend')
-      assert.strictEqual(config.tags.region, 'us-east')
-    })
-
-    it('should clear tracing_sampling_rules when not in merged config', () => {
-      const config = getConfig()
-      const originalRules = config.sampler.rules
-
-      // Apply remote config with sampling rules
-      config.setRemoteConfig({
-        tracing_sampling_rules: [{ sample_rate: 0.5 }]
-      })
-
-      // Rules should be set from RC
-      assert.deepStrictEqual(config.sampler.rules, [{ sampleRate: 0.5 }])
-
-      // Apply remote config without tracing_sampling_rules
-      config.setRemoteConfig({ tracing_enabled: true })
-
-      // Rules should fall back to original
-      assert.deepStrictEqual(config.sampler.rules, originalRules)
+      assert.strictEqual(config.logInjection, true)
+      assert.strictEqual(config.sampleRate, undefined)
     })
   })
 })

packages/dd-trace/test/config/remote_config.spec.js

@@ -44,6 +44,10 @@ describe('Tracing Remote Config', () => {
       sinon.assert.calledWithExactly(rc.updateCapabilities, RemoteConfigCapabilities.APM_TRACING_ENABLED, true)
       sinon.assert.calledWithExactly(rc.updateCapabilities, RemoteConfigCapabilities.APM_TRACING_SAMPLE_RULES, true)
       sinon.assert.calledWithExactly(rc.updateCapabilities, RemoteConfigCapabilities.APM_TRACING_MULTICONFIG, true)
+      sinon.assert.calledWithExactly(rc.updateCapabilities,
+        RemoteConfigCapabilities.APM_TRACING_ENABLE_DYNAMIC_INSTRUMENTATION, true)
+      sinon.assert.calledWithExactly(rc.updateCapabilities,
+        RemoteConfigCapabilities.APM_TRACING_ENABLE_CODE_ORIGIN, true)
     })
 
     it('should register APM_TRACING batch handler', () => {
@@ -229,19 +233,6 @@ describe('Tracing Remote Config', () => {
       })
     })
 
-    it('should call onConfigUpdated callback', () => {
-      enable(rc, config, onConfigUpdated)
-      const handler = batchHandlers.get('APM_TRACING')
-
-      const transaction = createTransaction([
-        { id: 'config-1', file: { lib_config: {} } }
-      ])
-
-      handler(transaction)
-
-      sinon.assert.calledOnce(onConfigUpdated)
-    })
-
     it('should return null when configs have no lib_config field', () => {
       enable(rc, config, onConfigUpdated)
       const handler = batchHandlers.get('APM_TRACING')