ddtrace 1.11.0.beta1 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83276ed5293cf8971f19f7a1fb1198e01f5ff8d48d3dd440deff0ef3518939d6
-  data.tar.gz: 12d22b6020e8830c91b2f68aed9ce03a2d201eafc4911c0a95171df6480cf754
+  metadata.gz: bf1177aae94a3724758e48ce461638de0a4b75956c8c1318251f2b568de28c5d
+  data.tar.gz: f42454cd32ff7eaf91c7beda1e6ff8a99726efddc8e01fdb4797b4f115c29df4
 SHA512:
-  metadata.gz: 4d4f7fb37bd10399053c026ff92545c5a1d600447cb94b3b35439fb37008154687c09f1834115afe4ed5cddc55fe84b458db955fcd4dbd0140444ffdaa01f8a9
-  data.tar.gz: 39d5ac62e456654550f70989e18dd3b122d3167aefc4a6b55ed5dc2ffd22c8f2b51c2f8261b2e4c009310acc2001be1a8f6ab6b0651850a45cc49cf0319ba6b1
+  metadata.gz: 5d5787eb9f073043151922af478a75affcfe8f2a9723fbe6c8e0561be6c7f95c700c91e1f4ca10401e018f1587f0289b1720d5c38e2cccdb80f7fcffd7eba0ba
+  data.tar.gz: 5f9d0adcfc38de9d60c51a46360ce60351228db21cabd07dc176a99f4bf77f80b0cc8f12dbe844ea3ae88f2384174158415a28de3e6adc1b6b54e56be1186665

data/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 ## [Unreleased]
 
+## [1.11.0] - 2023-04-27
+
+### Highlights
+
+As of ddtrace 1.11.0, these features are GA and emabled by default:
+
+- CPU Profiling 2.0
+- Remote Configuration
+- Telemetry
+
+For more details, check the release notes.
+
+### Added
+
+* Add remote configuration, enabled by default ([#2674][], [#2678][], [#2686][], [#2687][], [#2688][], [#2689][], [#2696][], [#2705][], [#2731][], [#2732][], [#2733][], [#2739][], [#2756][], [#2769][], [#2771][], [#2773][], [#2789][], [#2805][], [#2794][])
+* AppSec: Add response headers passing to WAF ([#2701][])
+* Tracing: Distributed tracing for Sidekiq ([#2513][])
+* Tracing: Add Roda integration ([#2368][])
+* Profiling: Support disabling endpoint names collection in new profiler ([#2698][])
+* Tracing: Support Sidekiq 7 ([#2810][])
+* Core: Add support for Unix Domain Socket (UDS) configuration via `DD_TRACE_AGENT_URL` ([#2806][])
+* Core: Enable Telemetry by default ([#2762][])
+
+### Changed
+
+* Core: Allow `1` as true value in environment variables ([#2710][])
+* Profiling: Enable CPU Profiling 2.0 by default ([#2702][])
+* Tracing: Improve controller instrumentation and deprecate option `exception_controller` ([#2726][])
+* Tracing: Implement Span Attribute Schema Environment Variable ([#2727][])
+* Tracing: Change default `service_name` values (gated by feature flag) ([#2760][])
+
+### Fixed
+
+* Bug: Tracing: Fix w3c propagation special character handling ([#2720][])
+* Performance: Tracing: Use `+@` instead of `dup` for duplicating strings ([#2704][])
+* Profiling: Avoid triggering allocation sampling during sampling ([#2690][])
+* Integrations: Tracing: Fix Rails < 3 conditional check in Utils#railtie_supported? ([#2695][])
+* Profiling: Do not auto-enable new profiler when rugged gem is detected ([#2741][])
+* Tracing: Fix using SemanticLogger#log(severity, message, progname) ([#2748][]) ([@rqz13][])
+* Profiling: Improve detection of mysql2 gem incompatibilities with profiler ([#2770][])
+* AppSec: Remove check for `::Rack::Request.instance_methods.include?(:each_header)` at load time ([#2778][])
+* Tracing: Fix quadratic backtracking on invalid URI ([#2788][])
+* Community: Correctly set mutex ([#2757][]) ([@ixti][])
+
+Read the [full changeset](https://github.com/DataDog/dd-trace-rb/compare/v1.10.1...v1.11.0.beta1) and the release [milestone](https://github.com/DataDog/dd-trace-rb/milestone/121?closed=1).
+
 ## [1.11.0.beta1] - 2023-04-14
 
 As of ddtrace 1.11.0.beta1, CPU Profiling 2.0 is now GA and enabled by default. For more details, check the release notes.
@@ -2356,7 +2402,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.11.0.beta1...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.11.0...master
+[1.11.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.10.1...v1.11.0
 [1.11.0.beta1]: https://github.com/DataDog/dd-trace-rb/compare/v1.10.1...v1.11.0.beta1
 [1.10.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.10.0...v1.10.1
 [1.10.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.9.0...v1.10.0
@@ -3396,6 +3443,9 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2741]: https://github.com/DataDog/dd-trace-rb/issues/2741
 [#2748]: https://github.com/DataDog/dd-trace-rb/issues/2748
 [#2756]: https://github.com/DataDog/dd-trace-rb/issues/2756
+[#2757]: https://github.com/DataDog/dd-trace-rb/issues/2757
+[#2760]: https://github.com/DataDog/dd-trace-rb/issues/2760
+[#2762]: https://github.com/DataDog/dd-trace-rb/issues/2762
 [#2769]: https://github.com/DataDog/dd-trace-rb/issues/2769
 [#2770]: https://github.com/DataDog/dd-trace-rb/issues/2770
 [#2771]: https://github.com/DataDog/dd-trace-rb/issues/2771
@@ -3403,6 +3453,10 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2778]: https://github.com/DataDog/dd-trace-rb/issues/2778
 [#2788]: https://github.com/DataDog/dd-trace-rb/issues/2788
 [#2789]: https://github.com/DataDog/dd-trace-rb/issues/2789
+[#2794]: https://github.com/DataDog/dd-trace-rb/issues/2794
+[#2805]: https://github.com/DataDog/dd-trace-rb/issues/2805
+[#2806]: https://github.com/DataDog/dd-trace-rb/issues/2806
+[#2810]: https://github.com/DataDog/dd-trace-rb/issues/2810
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -3481,6 +3535,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@hs-bguven]: https://github.com/hs-bguven
 [@illdelph]: https://github.com/illdelph
 [@ioquatix]: https://github.com/ioquatix
+[@ixti]: https://github.com/ixti
 [@jamiehodge]: https://github.com/jamiehodge
 [@janz93]: https://github.com/janz93
 [@jeffjo]: https://github.com/jeffjo

data/README.md

@@ -1,7 +1,6 @@
 # Datadog Trace Client
 
 [![Gem](https://img.shields.io/gem/v/ddtrace)](https://rubygems.org/gems/ddtrace/)
-[![CircleCI](https://circleci.com/gh/DataDog/dd-trace-rb/tree/master.svg?style=svg&circle-token=b0bd5ef866ec7f7b018f48731bb495f2d1372cc1)](https://circleci.com/gh/DataDog/dd-trace-rb/tree/master)
 [![codecov](https://codecov.io/gh/DataDog/dd-trace-rb/branch/master/graph/badge.svg)](https://app.codecov.io/gh/DataDog/dd-trace-rb/branch/master)
 [![YARD documentation](https://img.shields.io/badge/YARD-documentation-blue)][api docs]
 

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -118,6 +118,19 @@ struct cpu_and_wall_time_worker_state {
     unsigned int signal_handler_wrong_thread;
     // How many times we actually sampled (except GC samples)
     unsigned int sampled;
+    // How many times we skipped a sample because of the dynamic sampling rate mechanism
+    unsigned int skipped_sample_because_of_dynamic_sampling_rate;
+
+    // Stats for the results of calling rb_postponed_job_register_one
+      // The same function was already waiting to be executed
+    unsigned int postponed_job_skipped_already_existed;
+      // The function was added to the queue successfully
+    unsigned int postponed_job_success;
+      // The queue was full
+    unsigned int postponed_job_full;
+      // The function returned an unknown result code
+    unsigned int postponed_job_unknown_result;
+
     // Min/max/total wall-time spent sampling (except GC samples)
     uint64_t sampling_time_ns_min;
     uint64_t sampling_time_ns_max;
@@ -438,8 +451,20 @@ static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
 
   // Note: If we ever want to get rid of rb_postponed_job_register_one, remember not to clobber Ruby exceptions, as
   // this function does this helpful job for us now -- https://github.com/ruby/ruby/commit/a98e343d39c4d7bf1e2190b076720f32d9f298b3.
-  /*int result =*/ rb_postponed_job_register_one(0, sample_from_postponed_job, NULL);
-  // TODO: Do something with result (potentially update tracking counters?)
+  int result = rb_postponed_job_register_one(0, sample_from_postponed_job, NULL);
+
+  // Officially, the result of rb_postponed_job_register_one is documented as being opaque, but in practice it does not
+  // seem to have changed between Ruby 2.3 and 3.2, and so we track it as a debugging mechanism
+  switch (result) {
+    case 0:
+      state->stats.postponed_job_full++; break;
+    case 1:
+      state->stats.postponed_job_success++; break;
+    case 2:
+      state->stats.postponed_job_skipped_already_existed++; break;
+    default:
+      state->stats.postponed_job_unknown_result++;
+  }
 }
 
 // The actual sampling trigger loop always runs **without** the global vm lock.
@@ -451,9 +476,6 @@ static void *run_sampling_trigger_loop(void *state_ptr) {
   while (atomic_load(&state->should_run)) {
     state->stats.trigger_sample_attempts++;
 
-    // TODO: This is still a placeholder for a more complex mechanism. In particular:
-    // * We want to do more than having a fixed sampling rate
-
     current_gvl_owner owner = gvl_owner();
     if (owner.valid) {
       // Note that reading the GVL owner and sending them a signal is a race -- the Ruby VM keeps on executing while
@@ -519,8 +541,8 @@ static VALUE rescued_sample_from_postponed_job(VALUE self_instance) {
 
   long wall_time_ns_before_sample = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
 
-  if (!dynamic_sampling_rate_should_sample(&state->dynamic_sampling_rate, wall_time_ns_before_sample)) {
-    // TODO: Add a counter for this
+  if (state->dynamic_sampling_rate_enabled && !dynamic_sampling_rate_should_sample(&state->dynamic_sampling_rate, wall_time_ns_before_sample)) {
+    state->stats.skipped_sample_because_of_dynamic_sampling_rate++;
     return Qnil;
   }
 
@@ -777,6 +799,11 @@ static VALUE _native_stats(DDTRACE_UNUSED VALUE self, VALUE instance) {
     ID2SYM(rb_intern("signal_handler_enqueued_sample")),             /* => */ UINT2NUM(state->stats.signal_handler_enqueued_sample),
     ID2SYM(rb_intern("signal_handler_wrong_thread")),                /* => */ UINT2NUM(state->stats.signal_handler_wrong_thread),
     ID2SYM(rb_intern("sampled")),                                    /* => */ UINT2NUM(state->stats.sampled),
+    ID2SYM(rb_intern("skipped_sample_because_of_dynamic_sampling_rate")), /* => */ UINT2NUM(state->stats.skipped_sample_because_of_dynamic_sampling_rate),
+    ID2SYM(rb_intern("postponed_job_skipped_already_existed")),      /* => */ UINT2NUM(state->stats.postponed_job_skipped_already_existed),
+    ID2SYM(rb_intern("postponed_job_success")),                      /* => */ UINT2NUM(state->stats.postponed_job_success),
+    ID2SYM(rb_intern("postponed_job_full")),                         /* => */ UINT2NUM(state->stats.postponed_job_full),
+    ID2SYM(rb_intern("postponed_job_unknown_result")),               /* => */ UINT2NUM(state->stats.postponed_job_unknown_result),
     ID2SYM(rb_intern("sampling_time_ns_min")),                       /* => */ pretty_sampling_time_ns_min,
     ID2SYM(rb_intern("sampling_time_ns_max")),                       /* => */ pretty_sampling_time_ns_max,
     ID2SYM(rb_intern("sampling_time_ns_total")),                     /* => */ pretty_sampling_time_ns_total,

data/lib/datadog/appsec/component.rb

@@ -53,7 +53,7 @@ module Datadog
           if new && new.ready?
             old = @processor
             @processor = new
-            old.finalize
+            old.finalize if old
           end
         end
       end

data/lib/datadog/appsec/contrib/rack/request_middleware.rb

@@ -23,12 +23,11 @@ module Datadog
             @oneshot_tags_sent = false
           end
 
-          # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          # rubocop:disable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/MethodLength
           def call(env)
             return @app.call(env) unless Datadog::AppSec.enabled?
 
             Datadog::Core::Remote.active_remote.barrier(:once) unless Datadog::Core::Remote.active_remote.nil?
-            processor = Datadog::AppSec.processor
 
             processor = nil
             ready = false
@@ -89,7 +88,7 @@ module Datadog
               processor.deactivate_context
             end
           end
-          # rubocop:enable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          # rubocop:enable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/MethodLength
 
           private
 

data/lib/datadog/core/configuration/agent_settings_resolver.rb

@@ -95,9 +95,7 @@ module Datadog
         end
 
         def adapter
-          # If no agent settings have been provided, we try to connect using a local unix socket.
-          # We only do so if the socket is present when `ddtrace` runs.
-          if should_use_uds_fallback?
+          if should_use_uds? && !mixed_http_and_uds?
             Datadog::Transport::Ext::UnixSocket::ADAPTER
           else
             Datadog::Transport::Ext::HTTP::ADAPTER
@@ -118,7 +116,7 @@ module Datadog
             ),
             DetectedConfiguration.new(
               friendly_name: "#{Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_URL} environment variable",
-              value: parsed_url && parsed_url.hostname
+              value: parsed_http_url && parsed_http_url.hostname
             ),
             DetectedConfiguration.new(
               friendly_name: "#{Datadog::Core::Configuration::Ext::Transport::ENV_DEFAULT_HOST} environment variable",
@@ -141,7 +139,7 @@ module Datadog
             ),
             DetectedConfiguration.new(
               friendly_name: "#{Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_URL} environment variable",
-              value: parsed_url && parsed_url.port,
+              value: parsed_http_url && parsed_http_url.port,
             ),
             try_parsing_as_integer(
               friendly_name: "#{Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_PORT} environment variable",
@@ -169,16 +167,29 @@ module Datadog
         end
 
         def hostname
-          configured_hostname || (should_use_uds_fallback? ? nil : Datadog::Transport::Ext::HTTP::DEFAULT_HOST)
+          configured_hostname || (should_use_uds? ? nil : Datadog::Transport::Ext::HTTP::DEFAULT_HOST)
         end
 
         def port
-          configured_port || (should_use_uds_fallback? ? nil : Datadog::Transport::Ext::HTTP::DEFAULT_PORT)
+          configured_port || (should_use_uds? ? nil : Datadog::Transport::Ext::HTTP::DEFAULT_PORT)
         end
 
         # Unix socket path in the file system
         def uds_path
-          uds_fallback
+          if mixed_http_and_uds?
+            nil
+          elsif parsed_url && unix_scheme?(parsed_url)
+            path = parsed_url.to_s
+            # Some versions of the built-in uri gem leave the original url untouched, and others remove the //, so this
+            # supports both
+            if path.start_with?('unix://')
+              path.sub('unix://', '')
+            else
+              path.sub('unix:', '')
+            end
+          else
+            uds_fallback
+          end
         end
 
         # Defaults to +nil+, letting the adapter choose what default
@@ -210,8 +221,11 @@ module Datadog
             end
         end
 
-        def should_use_uds_fallback?
-          uds_fallback != nil
+        def should_use_uds?
+          parsed_url && unix_scheme?(parsed_url) ||
+            # If no agent settings have been provided, we try to connect using a local unix socket.
+            # We only do so if the socket is present when `ddtrace` runs.
+            !uds_fallback.nil?
         end
 
         def parsed_url
@@ -223,7 +237,7 @@ module Datadog
             if unparsed_url_from_env
               parsed = URI.parse(unparsed_url_from_env)
 
-              if %w[http https].include?(parsed.scheme)
+              if http_scheme?(parsed) || unix_scheme?(parsed)
                 parsed
               else
                 # rubocop:disable Layout/LineLength
@@ -266,6 +280,43 @@ module Datadog
           logger.warn(message) if logger
         end
 
+        def http_scheme?(uri)
+          ['http', 'https'].include?(uri.scheme)
+        end
+
+        # Expected to return nil (not false!) when it's not http
+        def parsed_http_url
+          parsed_url if parsed_url && http_scheme?(parsed_url)
+        end
+
+        def unix_scheme?(uri)
+          uri.scheme == 'unix'
+        end
+
+        # When we have mixed settings for http/https and uds, we print a warning and ignore the uds settings
+        def mixed_http_and_uds?
+          return @mixed_http_and_uds if defined?(@mixed_http_and_uds)
+
+          @mixed_http_and_uds = (configured_hostname || configured_port) && should_use_uds?
+
+          if @mixed_http_and_uds
+            warn_if_configuration_mismatch(
+              [
+                DetectedConfiguration.new(
+                  friendly_name: 'configuration of hostname/port for http/https use',
+                  value: "hostname: '#{configured_hostname}', port: #{configured_port.inspect}",
+                ),
+                DetectedConfiguration.new(
+                  friendly_name: 'configuration for unix domain socket',
+                  value: "unix://#{uds_path}",
+                ),
+              ]
+            )
+          end
+
+          @mixed_http_and_uds
+        end
+
         # The settings.tracing.transport_options allows users to have full control over the settings used to
         # communicate with the agent. In the general case, we can't extract the configuration from this proc, but
         # in the specific case of the http and unix socket adapters we can, and we use this method together with the

data/lib/datadog/core/configuration/settings.rb

@@ -468,11 +468,11 @@ module Datadog
         settings :telemetry do
           # Enable telemetry collection. This allows telemetry events to be emitted to the telemetry API.
           #
-          # @default `DD_INSTRUMENTATION_TELEMETRY_ENABLED` environment variable, otherwise `false`. In a future release,
-          #   this value will be changed to `true` by default as documented [here](https://docs.datadoghq.com/tracing/configure_data_security/#telemetry-collection).
+          # @default `DD_INSTRUMENTATION_TELEMETRY_ENABLED` environment variable, otherwise `true`.
+          #   Can be disabled as documented [here](https://docs.datadoghq.com/tracing/configure_data_security/#telemetry-collection).
           # @return [Boolean]
           option :enabled do |o|
-            o.default { env_to_bool(Core::Telemetry::Ext::ENV_ENABLED, false) }
+            o.default { env_to_bool(Core::Telemetry::Ext::ENV_ENABLED, true) }
             o.lazy
           end
         end
@@ -482,11 +482,10 @@ module Datadog
         settings :remote do
           # Enable remote configuration. This allows fetching of remote configuration for live updates.
           #
-          # @default `DD_REMOTE_CONFIGURATION_ENABLED` environment variable, otherwise `false`. In a future release,
-          #   this value will be changed to `true` by default.
+          # @default `DD_REMOTE_CONFIGURATION_ENABLED` environment variable, otherwise `true`.
           # @return [Boolean]
           option :enabled do |o|
-            o.default { env_to_bool(Core::Remote::Ext::ENV_ENABLED, false) }
+            o.default { env_to_bool(Core::Remote::Ext::ENV_ENABLED, true) }
             o.lazy
           end
 

data/lib/datadog/core/environment/identity.rb

@@ -49,9 +49,65 @@ module Datadog
           Core::Environment::Ext::LANG_VERSION
         end
 
+        # Returns tracer version, rubygems-style
         def tracer_version
           Core::Environment::Ext::TRACER_VERSION
         end
+
+        # Returns tracer version, comforming to https://semver.org/spec/v2.0.0.html
+        def tracer_version_semver2
+          # from ddtrace/version.rb, we have MAJOR.MINOR.PATCH plus optional .PRE and .BUILD
+          # - transform .PRE to -PRE if present
+          # - transform .BUILD to +BUILD if present
+          # - keep triplet segments before that
+
+          m = SEMVER2_RE.match(tracer_version)
+
+          pre = "-#{m[:pre]}" if m[:pre]
+          build = "+gha#{m[:gha_run_id]}.g#{m[:git_sha]}.#{m[:branch].tr('.', '-')}" if m[:build]
+
+          "#{m[:major]}.#{m[:minor]}.#{m[:patch]}#{pre}#{build}"
+        end
+
+        SEMVER2_RE = /
+          ^
+          # mandatory segments
+          (?<major>\d+)
+          \.
+          (?<minor>\d+)
+          \.
+          (?<patch>\d+)
+
+          # pre segments start with a value
+          # - containing at least one alpha
+          # - that is not part of our build segments expected values
+          # and stop with a value that is not part of our build segments expected values
+          (?:
+            \.
+            (?<pre>
+              (?!gha)
+              [a-zA-Z0-9]*[a-zA-Z][a-zA-Z0-9]*
+              (?:
+                \.
+                (?!gha)
+                [a-zA-Z0-9]+
+              )*
+            )
+          )?
+
+          # build segments: ours include CI info (`gha`), then git (`g`), then branch name
+          (?:
+            \.
+            (?<build>
+              gha(?<gha_run_id>\d+)
+              \.
+              g(?<git_sha>[a-f0-9]+)
+              \.
+              (?<branch>(?:[a-zA-Z0-9.])+)
+            )
+          )?
+          $
+        /xm.freeze
       end
     end
   end

data/lib/datadog/core/remote/client.rb

@@ -27,7 +27,7 @@ module Datadog
           end
         end
 
-        # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/CyclomaticComplexity
         def sync
           # TODO: Skip sync if no capabilities are registered
           response = transport.send_config(payload)
@@ -40,13 +40,20 @@ module Datadog
               return
             end
 
-            paths = response.client_configs.map do |path|
-              Configuration::Path.parse(path)
-            end
+            begin
+              paths = response.client_configs.map do |path|
+                Configuration::Path.parse(path)
+              end
 
-            targets = Configuration::TargetMap.parse(response.targets)
+              targets = Configuration::TargetMap.parse(response.targets)
 
-            contents = Configuration::ContentList.parse(response.target_files)
+              contents = Configuration::ContentList.parse(response.target_files)
+            rescue Remote::Configuration::Path::ParseError => e
+              raise SyncError, e.message
+            end
+
+            # To make sure steep does not complain
+            return unless paths && targets && contents
 
             # TODO: sometimes it can strangely be so that paths.empty?
             # TODO: sometimes it can strangely be so that targets.empty?
@@ -100,17 +107,44 @@ module Datadog
             else
               dispatcher.dispatch(changes, repository)
             end
-          else
-            raise SyncError, "unexpected transport response: #{response.inspect}"
           end
         end
-        # rubocop:enable Metrics/AbcSize,Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/CyclomaticComplexity
 
         private
 
-        def payload
+        def payload # rubocop:disable Metrics/MethodLength
           state = repository.state
 
+          client_tracer_tags = [
+            "platform:#{native_platform}", # native platform
+            # "asm.config.rules:#{}", # TODO: defined|undefined
+            # "asm.config.enabled:#{}", # TODO: true|false|undefined
+            "ruby.tracer.version:#{Core::Environment::Identity.tracer_version}",
+            "ruby.runtime.platform:#{RUBY_PLATFORM}",
+            "ruby.runtime.version:#{RUBY_VERSION}",
+            "ruby.runtime.engine.name:#{RUBY_ENGINE}",
+            "ruby.runtime.engine.version:#{ruby_engine_version}",
+            "ruby.rubygems.platform.local:#{Gem::Platform.local}",
+            "ruby.gem.libddwaf.version:#{gem_spec('libddwaf').version}",
+            "ruby.gem.libddwaf.platform:#{gem_spec('libddwaf').platform}",
+            "ruby.gem.libdatadog.version:#{gem_spec('libdatadog').version}",
+            "ruby.gem.libdatadog.platform:#{gem_spec('libdatadog').platform}",
+          ]
+
+          client_tracer = {
+            runtime_id: Core::Environment::Identity.id,
+            language: Core::Environment::Identity.lang,
+            tracer_version: tracer_version_semver2,
+            service: Datadog.configuration.service,
+            env: Datadog.configuration.env,
+            tags: client_tracer_tags,
+          }
+
+          app_version = Datadog.configuration.version
+
+          client_tracer[:app_version] = app_version if app_version
+
           {
             client: {
               state: {
@@ -125,21 +159,66 @@ module Datadog
               products: @capabilities.products,
               is_tracer: true,
               is_agent: false,
-              client_tracer: {
-                runtime_id: Core::Environment::Identity.id,
-                language: Core::Environment::Identity.lang,
-                tracer_version: Core::Environment::Identity.tracer_version,
-                service: Datadog.configuration.service,
-                env: Datadog.configuration.env,
-                # app_version: app_version, # TODO: I don't know what this is
-                tags: [], # TODO: add nice tags!
-              },
+              client_tracer: client_tracer,
               # base64 is needed otherwise the Go agent fails with an unmarshal error
               capabilities: @capabilities.base64_capabilities
             },
             cached_target_files: state.cached_target_files,
           }
         end
+
+        def tracer_version_semver2
+          @tracer_version_semver2 ||= Core::Environment::Identity.tracer_version_semver2
+        end
+
+        def ruby_engine_version
+          @ruby_engine_version ||= defined?(RUBY_ENGINE_VERSION) ? RUBY_ENGINE_VERSION : RUBY_VERSION
+        end
+
+        def gem_spec(name)
+          (@gem_specs ||= {})[name] ||= ::Gem.loaded_specs[name] || GemSpecificationFallback.new(nil, nil)
+        end
+
+        def native_platform
+          return @native_platform unless @native_platform.nil?
+
+          os = if RUBY_ENGINE == 'jruby'
+                 os_name = java.lang.System.get_property('os.name')
+
+                 case os_name
+                 when /linux/i then 'linux'
+                 when /mac/i   then 'darwin'
+                 else os_name
+                 end
+               else
+                 Gem::Platform.local.os
+               end
+
+          version = if os != 'linux'
+                      nil
+                    elsif RUBY_PLATFORM =~ /linux-(.+)$/
+                      # Old rubygems don't handle non-gnu linux correctly
+                      Regexp.last_match(1)
+                    else
+                      'gnu'
+                    end
+
+          cpu = if RUBY_ENGINE == 'jruby'
+                  os_arch = java.lang.System.get_property('os.arch')
+
+                  case os_arch
+                  when 'amd64' then 'x86_64'
+                  when 'aarch64' then os == 'darwin' ? 'arm64' : 'aarch64'
+                  else os_arch
+                  end
+                else
+                  Gem::Platform.local.cpu
+                end
+
+          @native_platform = [cpu, os, version].compact.join('-')
+        end
+
+        GemSpecificationFallback = _ = Struct.new(:version, :platform) # rubocop:disable Naming/ConstantName
       end
     end
   end