From 0fb021d10467669c89affb7361feaed1ca48a814 Mon Sep 17 00:00:00 2001 From: Ivo Anjo Date: Mon, 21 Aug 2023 15:26:13 +0100 Subject: [PATCH 01/49] Remove broken "Test unstable" GitHub action **What does this PR do?**: The "Test unstable" GitHub Action runs the dd-trace-rb CI with ruby-head and jruby-head. Because ruby-head and jruby-head aren't always rock solid, we've marked these tests with "continue-on-error: true" which in practice means you need to actually open them to know if they failed, because they get always marked as succeeded. Today, while looking into our CI config, I noticed these tests have been broken for what looks like *months* (due to some refactoring in our gemspec): ``` [!] There was an error parsing `Gemfile`: [!] There was an error while loading `ddtrace.gemspec`: syntax error, unexpected ']', expecting `end' or dummy end - ...ERSION::MAXIMUM_RUBY_VERSION}"] ... ^ . Bundler cannot continue. # from /home/runner/work/dd-trace-rb/dd-trace-rb/ddtrace.gemspec:10 # ------------------------------------------- # spec.version = DDTrace::VERSION::STRING > "< #{DDTrace::VERSION::MAXIMUM_RUBY_VERSION}"] # spec.required_rubygems_version = '>= 2.0.0' # ------------------------------------------- . Bundler cannot continue. # from /home/runner/work/dd-trace-rb/dd-trace-rb/Gemfile:3 # ------------------------------------------- # > gemspec # # ------------------------------------------- Error: The process '/home/runner/.rubies/ruby-head/bin/bundle' failed with exit code 14 ``` (https://github.com/DataDog/dd-trace-rb/actions/runs/5890935813/job/15977021676) Nobody seems to notice when they fail, and thus it really looks like we're not getting any value at all. Thus, I decided to open a PR to remove them for now. **Motivation**: As our CI gets more complex, we get little value from things that need to be checked manually -- nowadays we have hundreds of validations. **Additional Notes**: N/A **How to test the change?**: Validate that CI is still green, and this action no longer runs. --- .github/workflows/test-head.yaml | 41 -------------------------------- 1 file changed, 41 deletions(-) delete mode 100644 .github/workflows/test-head.yaml diff --git a/.github/workflows/test-head.yaml b/.github/workflows/test-head.yaml deleted file mode 100644 index d1905eb8d85..00000000000 --- a/.github/workflows/test-head.yaml +++ /dev/null @@ -1,41 +0,0 @@ -name: Test unstable -on: [push] -jobs: - test-head: - strategy: - fail-fast: false - matrix: - ruby: [head, jruby-head] - runs-on: ubuntu-latest - env: - SKIP_SIMPLECOV: 1 - JRUBY_OPTS: --dev - DD_INSTRUMENTATION_TELEMETRY_ENABLED: false - DD_REMOTE_CONFIGURATION_ENABLED: false - steps: - - uses: actions/checkout@v4 - # bundler appears to match both prerelease and release rubies when we - # want the former only. relax the constraint to allow any version for - # head rubies - - run: sed -i~ -e '/spec\.required_ruby_version/d' ddtrace.gemspec - - uses: ruby/setup-ruby@v1 - with: - ruby-version: ${{ matrix.ruby }} - bundler-cache: true # runs 'bundle install' and caches installed gems automatically - continue-on-error: true - - run: bundle exec rake spec:main - continue-on-error: true - - run: bundle exec rake spec:contrib - continue-on-error: true - - run: bundle exec rake spec:opentracer - continue-on-error: true - # A few contrib jobs that `ddtrace` already includes their gem in the global Gemfile. - # We technically don't need appraisal to run them, thus are easy candidates for early testing. - - run: bundle exec rake spec:rake - continue-on-error: true - - run: bundle exec rake spec:rspec - continue-on-error: true - - run: bundle exec rake spec:concurrent_ruby - continue-on-error: true - - run: bundle exec rake spec:http - continue-on-error: true From 70329a90465d18c50a396c6cdcf806639707c110 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Wed, 12 Jun 2024 14:08:01 +0200 Subject: [PATCH 02/49] add signatures and enable type checking for Core::Telemetry module --- Steepfile | 19 ------- lib/datadog/core/telemetry/event.rb | 1 + lib/datadog/core/telemetry/heartbeat.rb | 2 +- sig/datadog/core.rbs | 1 + sig/datadog/core/telemetry/client.rbs | 20 +++---- sig/datadog/core/telemetry/emitter.rbs | 2 +- sig/datadog/core/telemetry/event.rbs | 53 ++++++++++++++++++- sig/datadog/core/telemetry/heartbeat.rbs | 11 ++-- .../core/telemetry/http/adapters/net.rbs | 17 +++--- sig/datadog/core/telemetry/http/ext.rbs | 6 +++ sig/datadog/core/telemetry/http/response.rbs | 2 + sig/datadog/core/telemetry/http/transport.rbs | 14 ++--- sig/datadog/core/transport/ext.rbs | 2 + sig/datadog/core/worker.rbs | 1 + 14 files changed, 100 insertions(+), 51 deletions(-) diff --git a/Steepfile b/Steepfile index e8981eb0516..01dbc38f9db 100644 --- a/Steepfile +++ b/Steepfile @@ -93,25 +93,6 @@ target :ddtrace do ignore 'lib/datadog/core/pin.rb' ignore 'lib/datadog/core/runtime/ext.rb' ignore 'lib/datadog/core/runtime/metrics.rb' - ignore 'lib/datadog/core/telemetry/client.rb' - ignore 'lib/datadog/core/telemetry/collector.rb' - ignore 'lib/datadog/core/telemetry/emitter.rb' - ignore 'lib/datadog/core/telemetry/event.rb' - ignore 'lib/datadog/core/telemetry/ext.rb' - ignore 'lib/datadog/core/telemetry/heartbeat.rb' - ignore 'lib/datadog/core/telemetry/http/adapters/net.rb' - ignore 'lib/datadog/core/telemetry/http/env.rb' - ignore 'lib/datadog/core/telemetry/http/ext.rb' - ignore 'lib/datadog/core/telemetry/http/response.rb' - ignore 'lib/datadog/core/telemetry/http/transport.rb' - ignore 'lib/datadog/core/telemetry/v1/app_event.rb' - ignore 'lib/datadog/core/telemetry/v1/application.rb' - ignore 'lib/datadog/core/telemetry/v1/configuration.rb' - ignore 'lib/datadog/core/telemetry/v1/dependency.rb' - ignore 'lib/datadog/core/telemetry/v1/host.rb' - ignore 'lib/datadog/core/telemetry/v1/integration.rb' - ignore 'lib/datadog/core/telemetry/v1/product.rb' - ignore 'lib/datadog/core/telemetry/v1/telemetry_request.rb' ignore 'lib/datadog/core/transport/ext.rb' ignore 'lib/datadog/core/transport/http/adapters/net.rb' ignore 'lib/datadog/core/transport/http/adapters/registry.rb' diff --git a/lib/datadog/core/telemetry/event.rb b/lib/datadog/core/telemetry/event.rb index 569d5722afb..79729ff3ba0 100644 --- a/lib/datadog/core/telemetry/event.rb +++ b/lib/datadog/core/telemetry/event.rb @@ -38,6 +38,7 @@ def payload(seq_id) private def products + # @type var products: Hash[Symbol, Hash[Symbol, Object]] products = { appsec: { enabled: Datadog::AppSec.enabled?, diff --git a/lib/datadog/core/telemetry/heartbeat.rb b/lib/datadog/core/telemetry/heartbeat.rb index bf94318059a..b2129504e68 100644 --- a/lib/datadog/core/telemetry/heartbeat.rb +++ b/lib/datadog/core/telemetry/heartbeat.rb @@ -6,7 +6,7 @@ module Datadog module Core module Telemetry - # Periodically (every DEFAULT_INTERVAL_SECONDS) sends a heartbeat event to the telemetry API. + # Periodically sends a heartbeat event to the telemetry API. class Heartbeat < Core::Worker include Core::Workers::Polling diff --git a/sig/datadog/core.rbs b/sig/datadog/core.rbs index 230abdce92e..410f4f2cd29 100644 --- a/sig/datadog/core.rbs +++ b/sig/datadog/core.rbs @@ -3,4 +3,5 @@ module Datadog end extend Core::Configuration + extend Tracing::Contrib::Extensions::Helpers end diff --git a/sig/datadog/core/telemetry/client.rbs b/sig/datadog/core/telemetry/client.rbs index bc572c05a87..9bd2f4a97cc 100644 --- a/sig/datadog/core/telemetry/client.rbs +++ b/sig/datadog/core/telemetry/client.rbs @@ -2,37 +2,37 @@ module Datadog module Core module Telemetry class Client + @enabled: bool @dependency_collection: bool @started: bool @stopped: bool - - attr_reader emitter: untyped + @emitter: Datadog::Core::Telemetry::Emitter + @unsupported: bool + @worker: Datadog::Core::Telemetry::Heartbeat attr_reader enabled: bool attr_reader unsupported: bool - attr_reader worker: untyped - include Core::Utils::Forking def initialize: (heartbeat_interval_seconds: Numeric, dependency_collection: bool, enabled: bool) -> void - def disable!: () -> untyped + def disable!: () -> void def client_configuration_change!: (Enumerable[[String, Numeric | bool | String]] changes) -> void - def started!: () -> (nil | untyped) + def started!: () -> void - def emit_closing!: () -> (nil | untyped) + def emit_closing!: () -> void - def stop!: () -> (nil | untyped) + def stop!: () -> void - def integrations_change!: () -> (nil | untyped) + def integrations_change!: () -> void private - def heartbeat!: () -> (nil | untyped) + def heartbeat!: () -> void end end end diff --git a/sig/datadog/core/telemetry/emitter.rbs b/sig/datadog/core/telemetry/emitter.rbs index fa1eb05534d..e1d4320d763 100644 --- a/sig/datadog/core/telemetry/emitter.rbs +++ b/sig/datadog/core/telemetry/emitter.rbs @@ -8,7 +8,7 @@ module Datadog extend Core::Utils::Forking def initialize: (?http_transport: untyped) -> void - def request: (String request_type, data: Object?) -> Datadog::Core::Telemetry::Http::Adapters::Net::Response + def request: (Datadog::Core::Telemetry::Event::Base event) -> Datadog::Core::Telemetry::Http::Adapters::Net::Response def self.sequence: () -> untyped end end diff --git a/sig/datadog/core/telemetry/event.rbs b/sig/datadog/core/telemetry/event.rbs index ba45df34aba..4e0e3824109 100644 --- a/sig/datadog/core/telemetry/event.rbs +++ b/sig/datadog/core/telemetry/event.rbs @@ -3,8 +3,57 @@ module Datadog module Telemetry class Event class Base - def payload: (int seq_id) -> ::Hash[Symbol, Object] - def type: -> string + def payload: (int seq_id) -> Hash[Symbol, untyped] + def type: -> String? + end + + class AppStarted < Base + TARGET_OPTIONS: Array[String] + + @seq_id: int + + private + + def products: -> Hash[Symbol, untyped] + + def configuration: -> Array[Hash[Symbol, untyped]] + + def agent_transport: (untyped config) -> String + + def conf_value: (String name, Object value, ?String origin) -> Hash[Symbol, untyped] + + def to_value: (Object value) -> Object + + def install_signature: -> Hash[Symbol, Object] + end + + class AppDependenciesLoaded < Base + private + + def dependencies: -> Array[Hash[Symbol, String]] + end + + class AppIntegrationsChange < Base + private + + def integrations: -> Array[Hash[Symbol, string]] + + def patch_error: (untyped integration) -> String + end + + class AppClientConfigurationChange < Base + @changes: Enumerable[[String, Numeric | bool | String | int]] + @origin: String + + def initialize: (Enumerable[[String, Numeric | bool | String]] changes, String origin) -> void + + def configuration: (int seq_id) -> Array[Hash[Symbol, untyped]] + end + + class AppHeartbeat < Base + end + + class AppClosing < Base end end end diff --git a/sig/datadog/core/telemetry/heartbeat.rbs b/sig/datadog/core/telemetry/heartbeat.rbs index e1fcaae79fe..b89aeedca8b 100644 --- a/sig/datadog/core/telemetry/heartbeat.rbs +++ b/sig/datadog/core/telemetry/heartbeat.rbs @@ -3,16 +3,17 @@ module Datadog module Telemetry class Heartbeat < Core::Worker include Core::Workers::Polling + include Core::Workers::Async::Thread + include Core::Workers::Async::Thread::PrependedMethods + include Core::Workers::IntervalLoop - DEFAULT_INTERVAL_SECONDS: 60 + def initialize: (?enabled: bool, heartbeat_interval_seconds: Numeric) ?{ () -> void } -> void - def initialize: (?enabled: bool, ?interval: untyped) ?{ () -> untyped } -> void - - def loop_wait_before_first_iteration?: () -> true + def loop_wait_before_first_iteration?: () -> bool? private - def start: () -> untyped + def start: () -> void end end end diff --git a/sig/datadog/core/telemetry/http/adapters/net.rbs b/sig/datadog/core/telemetry/http/adapters/net.rbs index e3e57cf0acf..5cf50e53adf 100644 --- a/sig/datadog/core/telemetry/http/adapters/net.rbs +++ b/sig/datadog/core/telemetry/http/adapters/net.rbs @@ -4,21 +4,24 @@ module Datadog module Http module Adapters class Net - attr_reader hostname: untyped + type response = Datadog::Core::Telemetry::Http::Adapters::Net::Response | ::Datadog::Core::Telemetry::Http::InternalErrorResponse - attr_reader port: untyped + attr_reader hostname: String - attr_reader timeout: untyped + attr_reader port: Integer? - attr_reader ssl: untyped + attr_reader timeout: Float | Integer + + attr_reader ssl: bool DEFAULT_TIMEOUT: 30 - def initialize: (hostname: untyped, ?port: untyped?, ?timeout: untyped, ?ssl: bool) -> void + def initialize: (hostname: String, ?port: Integer?, ?timeout: Float | Integer, ?ssl: bool?) -> void + + def open: () { (::Net::HTTP http) -> ::Net::HTTPResponse } -> untyped - def open: () ?{ () -> untyped } -> untyped + def post: (untyped env) -> response - def post: (untyped env) -> Datadog::Core::Telemetry::Http::Adapters::Net::Response class Response include Datadog::Core::Telemetry::Http::Response diff --git a/sig/datadog/core/telemetry/http/ext.rbs b/sig/datadog/core/telemetry/http/ext.rbs index d471905fe2f..22cea7d1fd0 100644 --- a/sig/datadog/core/telemetry/http/ext.rbs +++ b/sig/datadog/core/telemetry/http/ext.rbs @@ -13,6 +13,12 @@ module Datadog HEADER_DD_TELEMETRY_REQUEST_TYPE: "DD-Telemetry-Request-Type" + HEADER_CLIENT_LIBRARY_LANGUAGE: "DD-Client-Library-Language" + + HEADER_CLIENT_LIBRARY_VERSION: "DD-Client-Library-Version" + + HEADER_TELEMETRY_DEBUG_ENABLED: "DD-Telemetry-Debug-Enabled" + CONTENT_TYPE_APPLICATION_JSON: "application/json" API_VERSION: "v1" diff --git a/sig/datadog/core/telemetry/http/response.rbs b/sig/datadog/core/telemetry/http/response.rbs index 95e92044cae..4113c007214 100644 --- a/sig/datadog/core/telemetry/http/response.rbs +++ b/sig/datadog/core/telemetry/http/response.rbs @@ -9,6 +9,8 @@ module Datadog def unsupported?: () -> nil + def code: () -> nil + def not_found?: () -> nil def client_error?: () -> nil diff --git a/sig/datadog/core/telemetry/http/transport.rbs b/sig/datadog/core/telemetry/http/transport.rbs index 2a707e66e48..d6ac33f5a40 100644 --- a/sig/datadog/core/telemetry/http/transport.rbs +++ b/sig/datadog/core/telemetry/http/transport.rbs @@ -3,23 +3,25 @@ module Datadog module Telemetry module Http class Transport - attr_reader host: untyped + @adapter: Http::Adapters::Net - attr_reader port: untyped + attr_reader host: String - attr_reader ssl: untyped + attr_reader port: Integer - attr_reader path: untyped + attr_reader ssl: bool + + attr_reader path: String def initialize: () -> void - def request: (request_type: String, payload: String) -> Datadog::Core::Telemetry::Http::Adapters::Net::Response + def request: (request_type: String, payload: String) -> Datadog::Core::Telemetry::Http::Adapters::Net::response private def headers: (request_type: untyped, ?api_version: untyped) -> ::Hash[untyped, untyped] - def adapter: () -> untyped + def adapter: () -> Http::Adapters::Net end end end diff --git a/sig/datadog/core/transport/ext.rbs b/sig/datadog/core/transport/ext.rbs index 8be8ba0bbbb..335e293b941 100644 --- a/sig/datadog/core/transport/ext.rbs +++ b/sig/datadog/core/transport/ext.rbs @@ -24,6 +24,8 @@ module Datadog HEADER_META_LANG_INTERPRETER: ::String HEADER_META_TRACER_VERSION: ::String + + HEADER_DD_INTERNAL_UNTRACED_REQUEST: ::String end module Test diff --git a/sig/datadog/core/worker.rbs b/sig/datadog/core/worker.rbs index 7c59eb58d60..5654f60e88d 100644 --- a/sig/datadog/core/worker.rbs +++ b/sig/datadog/core/worker.rbs @@ -1,6 +1,7 @@ module Datadog module Core class Worker + def initialize: () ?{ () -> void } -> void end end end From 890fc9b0e40915fd71dfda91b56cbe9a7d81378b Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Wed, 12 Jun 2024 16:42:36 +0200 Subject: [PATCH 03/49] rename Telemetry::Heartbeat to Telemetry::Worker --- lib/datadog/core/telemetry/client.rb | 4 ++-- .../core/telemetry/{heartbeat.rb => worker.rb} | 2 +- sig/datadog/core/telemetry/client.rbs | 2 +- sig/datadog/core/telemetry/http/ext.rbs | 2 +- .../telemetry/{heartbeat.rbs => worker.rbs} | 2 +- spec/datadog/core/telemetry/client_spec.rb | 4 ++-- .../{heartbeat_spec.rb => worker_spec.rb} | 18 +++++++++--------- 7 files changed, 17 insertions(+), 17 deletions(-) rename lib/datadog/core/telemetry/{heartbeat.rb => worker.rb} (95%) rename sig/datadog/core/telemetry/{heartbeat.rbs => worker.rbs} (92%) rename spec/datadog/core/telemetry/{heartbeat_spec.rb => worker_spec.rb} (63%) diff --git a/lib/datadog/core/telemetry/client.rb b/lib/datadog/core/telemetry/client.rb index 172145c9342..db5c01673ee 100644 --- a/lib/datadog/core/telemetry/client.rb +++ b/lib/datadog/core/telemetry/client.rb @@ -2,7 +2,7 @@ require_relative 'emitter' require_relative 'event' -require_relative 'heartbeat' +require_relative 'worker' require_relative '../utils/forking' module Datadog @@ -27,7 +27,7 @@ def initialize(heartbeat_interval_seconds:, dependency_collection:, enabled: tru @started = false @dependency_collection = dependency_collection - @worker = Telemetry::Heartbeat.new(enabled: @enabled, heartbeat_interval_seconds: heartbeat_interval_seconds) do + @worker = Telemetry::Worker.new(enabled: @enabled, heartbeat_interval_seconds: heartbeat_interval_seconds) do next unless @started # `started!` should be the first event, thus ensure that `heartbeat!` is not sent first. heartbeat! diff --git a/lib/datadog/core/telemetry/heartbeat.rb b/lib/datadog/core/telemetry/worker.rb similarity index 95% rename from lib/datadog/core/telemetry/heartbeat.rb rename to lib/datadog/core/telemetry/worker.rb index b2129504e68..8e0f106d0bd 100644 --- a/lib/datadog/core/telemetry/heartbeat.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -7,7 +7,7 @@ module Datadog module Core module Telemetry # Periodically sends a heartbeat event to the telemetry API. - class Heartbeat < Core::Worker + class Worker < Core::Worker include Core::Workers::Polling def initialize(heartbeat_interval_seconds:, enabled: true, &block) diff --git a/sig/datadog/core/telemetry/client.rbs b/sig/datadog/core/telemetry/client.rbs index 9bd2f4a97cc..79aa3850b1c 100644 --- a/sig/datadog/core/telemetry/client.rbs +++ b/sig/datadog/core/telemetry/client.rbs @@ -8,7 +8,7 @@ module Datadog @stopped: bool @emitter: Datadog::Core::Telemetry::Emitter @unsupported: bool - @worker: Datadog::Core::Telemetry::Heartbeat + @worker: Datadog::Core::Telemetry::Worker attr_reader enabled: bool diff --git a/sig/datadog/core/telemetry/http/ext.rbs b/sig/datadog/core/telemetry/http/ext.rbs index 22cea7d1fd0..11271822da3 100644 --- a/sig/datadog/core/telemetry/http/ext.rbs +++ b/sig/datadog/core/telemetry/http/ext.rbs @@ -21,7 +21,7 @@ module Datadog CONTENT_TYPE_APPLICATION_JSON: "application/json" - API_VERSION: "v1" + API_VERSION: "v2" AGENT_ENDPOINT: "/telemetry/proxy/api/v2/apmtelemetry" end diff --git a/sig/datadog/core/telemetry/heartbeat.rbs b/sig/datadog/core/telemetry/worker.rbs similarity index 92% rename from sig/datadog/core/telemetry/heartbeat.rbs rename to sig/datadog/core/telemetry/worker.rbs index b89aeedca8b..779cbd7aa6c 100644 --- a/sig/datadog/core/telemetry/heartbeat.rbs +++ b/sig/datadog/core/telemetry/worker.rbs @@ -1,7 +1,7 @@ module Datadog module Core module Telemetry - class Heartbeat < Core::Worker + class Worker < Core::Worker include Core::Workers::Polling include Core::Workers::Async::Thread include Core::Workers::Async::Thread::PrependedMethods diff --git a/spec/datadog/core/telemetry/client_spec.rb b/spec/datadog/core/telemetry/client_spec.rb index 5618d4ea65e..ebd59516a42 100644 --- a/spec/datadog/core/telemetry/client_spec.rb +++ b/spec/datadog/core/telemetry/client_spec.rb @@ -213,10 +213,10 @@ describe '#stop!' do subject(:stop!) { client.stop! } - let(:worker) { instance_double(Datadog::Core::Telemetry::Heartbeat) } + let(:worker) { instance_double(Datadog::Core::Telemetry::Worker) } before do - allow(Datadog::Core::Telemetry::Heartbeat).to receive(:new) + allow(Datadog::Core::Telemetry::Worker).to receive(:new) .with(enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds).and_return(worker) allow(worker).to receive(:start) allow(worker).to receive(:stop) diff --git a/spec/datadog/core/telemetry/heartbeat_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb similarity index 63% rename from spec/datadog/core/telemetry/heartbeat_spec.rb rename to spec/datadog/core/telemetry/worker_spec.rb index 645120267e0..532e2873375 100644 --- a/spec/datadog/core/telemetry/heartbeat_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -1,9 +1,9 @@ require 'spec_helper' -require 'datadog/core/telemetry/heartbeat' +require 'datadog/core/telemetry/worker' -RSpec.describe Datadog::Core::Telemetry::Heartbeat do - subject(:heartbeat) do +RSpec.describe Datadog::Core::Telemetry::Worker do + subject(:worker) do described_class.new(enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, &block) end @@ -12,13 +12,13 @@ let(:block) { proc {} } after do - heartbeat.stop(true, 0) - heartbeat.join + worker.stop(true, 0) + worker.join end describe '.new' do context 'when using default settings' do - subject(:heartbeat) { described_class.new(heartbeat_interval_seconds: heartbeat_interval_seconds, &block) } + subject(:worker) { described_class.new(heartbeat_interval_seconds: heartbeat_interval_seconds, &block) } it do is_expected.to have_attributes( enabled?: true, @@ -32,10 +32,10 @@ let(:enabled) { true } it do - heartbeat + worker - try_wait_until { heartbeat.running? } - expect(heartbeat).to have_attributes( + try_wait_until { worker.running? } + expect(worker).to have_attributes( run_async?: true, running?: true, started?: true From eb73019cf94d5f3b1fc5a0c20da01e60e41d5d4d Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Thu, 13 Jun 2024 13:33:40 +0200 Subject: [PATCH 04/49] Add queue to telemetry worker. Move sending heartbeat logic to the telemetry worker. --- lib/datadog/core/telemetry/client.rb | 20 ++++----- lib/datadog/core/telemetry/worker.rb | 31 +++++++++----- sig/datadog/core/telemetry/worker.rbs | 11 +++-- spec/datadog/core/telemetry/client_spec.rb | 3 +- spec/datadog/core/telemetry/worker_spec.rb | 47 +++++++++++++++------- 5 files changed, 70 insertions(+), 42 deletions(-) diff --git a/lib/datadog/core/telemetry/client.rb b/lib/datadog/core/telemetry/client.rb index db5c01673ee..eeeae58556e 100644 --- a/lib/datadog/core/telemetry/client.rb +++ b/lib/datadog/core/telemetry/client.rb @@ -27,11 +27,11 @@ def initialize(heartbeat_interval_seconds:, dependency_collection:, enabled: tru @started = false @dependency_collection = dependency_collection - @worker = Telemetry::Worker.new(enabled: @enabled, heartbeat_interval_seconds: heartbeat_interval_seconds) do - next unless @started # `started!` should be the first event, thus ensure that `heartbeat!` is not sent first. - - heartbeat! - end + @worker = Telemetry::Worker.new( + enabled: @enabled, + heartbeat_interval_seconds: heartbeat_interval_seconds, + emitter: @emitter + ) end def disable! @@ -51,6 +51,8 @@ def started! return res end + @worker.start + @emitter.request(Event::AppDependenciesLoaded.new) if @dependency_collection @started = true @@ -81,14 +83,6 @@ def client_configuration_change!(changes) @emitter.request(Event::AppClientConfigurationChange.new(changes, 'remote_config')) end - - private - - def heartbeat! - return if !@enabled || forked? - - @emitter.request(Event::AppHeartbeat.new) - end end end end diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index 8e0f106d0bd..5683f2028b7 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -1,31 +1,44 @@ # frozen_string_literal: true -require_relative '../worker' +require_relative 'event' + require_relative '../workers/polling' +require_relative '../workers/queue' module Datadog module Core module Telemetry - # Periodically sends a heartbeat event to the telemetry API. - class Worker < Core::Worker + # Accumulates events and sends them to the API at a regular interval, including heartbeat event. + class Worker + include Core::Workers::Queue include Core::Workers::Polling - def initialize(heartbeat_interval_seconds:, enabled: true, &block) + def initialize(heartbeat_interval_seconds:, emitter:, enabled: true) + @emitter = emitter + # Workers::Polling settings self.enabled = enabled # Workers::IntervalLoop settings self.loop_base_interval = heartbeat_interval_seconds self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP - super(&block) - start end - def loop_wait_before_first_iteration?; end + def start + return if !enabled? || forked? + + perform + end private - def start - perform + def perform(*_events) + return if !enabled? || forked? + + heartbeat! + end + + def heartbeat! + @emitter.request(Event::AppHeartbeat.new) end end end diff --git a/sig/datadog/core/telemetry/worker.rbs b/sig/datadog/core/telemetry/worker.rbs index 779cbd7aa6c..0fa008ebca9 100644 --- a/sig/datadog/core/telemetry/worker.rbs +++ b/sig/datadog/core/telemetry/worker.rbs @@ -1,19 +1,22 @@ module Datadog module Core module Telemetry - class Worker < Core::Worker + class Worker include Core::Workers::Polling include Core::Workers::Async::Thread include Core::Workers::Async::Thread::PrependedMethods include Core::Workers::IntervalLoop + include Core::Workers::Queue - def initialize: (?enabled: bool, heartbeat_interval_seconds: Numeric) ?{ () -> void } -> void + @emitter: Emitter - def loop_wait_before_first_iteration?: () -> bool? + def initialize: (?enabled: bool, heartbeat_interval_seconds: Numeric, emitter: Emitter) -> void + + def start: () -> void private - def start: () -> void + def heartbeat!: () -> void end end end diff --git a/spec/datadog/core/telemetry/client_spec.rb b/spec/datadog/core/telemetry/client_spec.rb index ebd59516a42..c8a89f6264f 100644 --- a/spec/datadog/core/telemetry/client_spec.rb +++ b/spec/datadog/core/telemetry/client_spec.rb @@ -217,7 +217,8 @@ before do allow(Datadog::Core::Telemetry::Worker).to receive(:new) - .with(enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds).and_return(worker) + .with(enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, emitter: emitter) + .and_return(worker) allow(worker).to receive(:start) allow(worker).to receive(:stop) end diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index 532e2873375..0a874112993 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -4,12 +4,16 @@ RSpec.describe Datadog::Core::Telemetry::Worker do subject(:worker) do - described_class.new(enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, &block) + described_class.new(enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, emitter: emitter) end let(:enabled) { true } let(:heartbeat_interval_seconds) { 1.2 } - let(:block) { proc {} } + let(:emitter) { double(Datadog::Core::Telemetry::Emitter) } + + before do + allow(emitter).to receive(:request) + end after do worker.stop(true, 0) @@ -17,29 +21,42 @@ end describe '.new' do - context 'when using default settings' do - subject(:worker) { described_class.new(heartbeat_interval_seconds: heartbeat_interval_seconds, &block) } - it do - is_expected.to have_attributes( - enabled?: true, - loop_base_interval: 1.2, # seconds - task: block - ) - end + it 'creates a new worker in stopped state' do + expect(worker).to have_attributes( + enabled?: true, + loop_base_interval: 1.2, # seconds + run_async?: false, + running?: false, + started?: false + ) end + end + describe '#start' do context 'when enabled' do - let(:enabled) { true } - - it do - worker + it 'starts the worker and sends heartbeat event' do + worker.start try_wait_until { worker.running? } + expect(worker).to have_attributes( + enabled?: true, + loop_base_interval: 1.2, # seconds run_async?: true, running?: true, started?: true ) + expect(emitter).to have_received(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) + end + end + + context 'when disabled' do + let(:enabled) { false } + + it 'does not start the worker' do + expect(worker).not_to receive(:perform) + + worker.start end end end From aea08621df444318b1115a6c142eceec51d6ad1f Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Thu, 13 Jun 2024 15:07:16 +0200 Subject: [PATCH 05/49] move AppStarted telemetry event out of the critical path --- lib/datadog/core/telemetry/client.rb | 14 +--- lib/datadog/core/telemetry/worker.rb | 21 ++++++ lib/datadog/core/workers/polling.rb | 1 + sig/datadog/core/telemetry/client.rbs | 7 -- sig/datadog/core/telemetry/worker.rbs | 5 ++ spec/datadog/core/telemetry/client_spec.rb | 55 +------------- spec/datadog/core/telemetry/worker_spec.rb | 86 ++++++++++++++++++---- 7 files changed, 103 insertions(+), 86 deletions(-) diff --git a/lib/datadog/core/telemetry/client.rb b/lib/datadog/core/telemetry/client.rb index eeeae58556e..07028e96ad5 100644 --- a/lib/datadog/core/telemetry/client.rb +++ b/lib/datadog/core/telemetry/client.rb @@ -10,9 +10,7 @@ module Core module Telemetry # Telemetry entrypoint, coordinates sending telemetry events at various points in app lifecycle. class Client - attr_reader \ - :enabled, - :unsupported + attr_reader :enabled include Core::Utils::Forking @@ -23,7 +21,6 @@ def initialize(heartbeat_interval_seconds:, dependency_collection:, enabled: tru @enabled = enabled @emitter = Emitter.new @stopped = false - @unsupported = false @started = false @dependency_collection = dependency_collection @@ -42,15 +39,6 @@ def disable! def started! return if !@enabled || forked? - res = @emitter.request(Event::AppStarted.new) - - if res.not_found? # Telemetry is only supported by agent versions 7.34 and up - Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.') - disable! - @unsupported = true # Prevent telemetry from getting re-enabled - return res - end - @worker.start @emitter.request(Event::AppDependenciesLoaded.new) if @dependency_collection diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index 5683f2028b7..9ff7702e747 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -16,6 +16,8 @@ class Worker def initialize(heartbeat_interval_seconds:, emitter:, enabled: true) @emitter = emitter + @sent_started_event = false + # Workers::Polling settings self.enabled = enabled # Workers::IntervalLoop settings @@ -26,20 +28,39 @@ def initialize(heartbeat_interval_seconds:, emitter:, enabled: true) def start return if !enabled? || forked? + # starts async worker perform end + def sent_started_event? + @sent_started_event + end + private def perform(*_events) return if !enabled? || forked? + unless @sent_started_event + started! + @sent_started_event = true + end + heartbeat! end def heartbeat! @emitter.request(Event::AppHeartbeat.new) end + + def started! + res = @emitter.request(Event::AppStarted.new) + + if res.not_found? # Telemetry is only supported by agent versions 7.34 and up + Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.') + self.enabled = false + end + end end end end diff --git a/lib/datadog/core/workers/polling.rb b/lib/datadog/core/workers/polling.rb index fd516f16f79..ab2c5057083 100644 --- a/lib/datadog/core/workers/polling.rb +++ b/lib/datadog/core/workers/polling.rb @@ -22,6 +22,7 @@ def perform(*args) end def stop(force_stop = false, timeout = DEFAULT_SHUTDOWN_TIMEOUT) + # p "in stop" if running? # Attempt graceful stop and wait stop_loop diff --git a/sig/datadog/core/telemetry/client.rbs b/sig/datadog/core/telemetry/client.rbs index 79aa3850b1c..e1646cb1eb8 100644 --- a/sig/datadog/core/telemetry/client.rbs +++ b/sig/datadog/core/telemetry/client.rbs @@ -7,13 +7,10 @@ module Datadog @started: bool @stopped: bool @emitter: Datadog::Core::Telemetry::Emitter - @unsupported: bool @worker: Datadog::Core::Telemetry::Worker attr_reader enabled: bool - attr_reader unsupported: bool - include Core::Utils::Forking def initialize: (heartbeat_interval_seconds: Numeric, dependency_collection: bool, enabled: bool) -> void @@ -29,10 +26,6 @@ module Datadog def stop!: () -> void def integrations_change!: () -> void - - private - - def heartbeat!: () -> void end end end diff --git a/sig/datadog/core/telemetry/worker.rbs b/sig/datadog/core/telemetry/worker.rbs index 0fa008ebca9..e1c5c09cf70 100644 --- a/sig/datadog/core/telemetry/worker.rbs +++ b/sig/datadog/core/telemetry/worker.rbs @@ -9,14 +9,19 @@ module Datadog include Core::Workers::Queue @emitter: Emitter + @sent_started_event: bool def initialize: (?enabled: bool, heartbeat_interval_seconds: Numeric, emitter: Emitter) -> void def start: () -> void + def sent_started_event?: () -> bool + private def heartbeat!: () -> void + + def started!: () -> void end end end diff --git a/spec/datadog/core/telemetry/client_spec.rb b/spec/datadog/core/telemetry/client_spec.rb index c8a89f6264f..8532ad80185 100644 --- a/spec/datadog/core/telemetry/client_spec.rb +++ b/spec/datadog/core/telemetry/client_spec.rb @@ -12,7 +12,7 @@ end let(:enabled) { true } - let(:heartbeat_interval_seconds) { 1.3 } + let(:heartbeat_interval_seconds) { 0 } let(:dependency_collection) { true } let(:emitter) { double(Datadog::Core::Telemetry::Emitter) } let(:response) { double(Datadog::Core::Telemetry::Http::Adapters::Net::Response) } @@ -83,15 +83,12 @@ context 'when dependency_collection is true' do it do - app_started = double - allow(Datadog::Core::Telemetry::Event::AppStarted).to receive(:new).with(no_args).and_return(app_started) - dependencies = double allow(Datadog::Core::Telemetry::Event::AppDependenciesLoaded) .to receive(:new).with(no_args).and_return(dependencies) started! - expect(emitter).to have_received(:request).with(app_started) + expect(emitter).to have_received(:request).with(dependencies) end end @@ -100,63 +97,17 @@ let(:dependency_collection) { false } it do - app_started = double - allow(Datadog::Core::Telemetry::Event::AppStarted).to receive(:new).with(no_args).and_return(app_started) - dependencies = double allow(Datadog::Core::Telemetry::Event::AppDependenciesLoaded) .to receive(:new).with(no_args).and_return(dependencies) started! - expect(emitter).to have_received(:request).with(app_started) - expect(emitter).to_not have_received(:request).with(dependencies) - end - - context 'with heartbeat' do - let(:heartbeat_interval_seconds) { 0 } - it 'sends a heartbeat strictly after app-started' do - @sent_hearbeat = false - allow(emitter).to receive(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) do - # Ensure app-started was already sent by now - expect(emitter).to have_received(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppStarted)) - @sent_hearbeat = true - response - end - - client.started! - - try_wait_until { @sent_hearbeat } - end + expect(emitter).to_not have_received(:request).with(dependencies) end end end - context 'when internal error returned by emitter' do - let(:response) { Datadog::Core::Telemetry::Http::InternalErrorResponse.new('error') } - - it { expect { started! }.to_not raise_error } - end - - context 'when response returns 404' do - let(:not_found) { true } - - before do - logger = double(Datadog::Core::Logger) - allow(logger).to receive(:debug).with(any_args) - allow(Datadog).to receive(:logger).and_return(logger) - end - - it do - started! - expect(client.enabled).to be(false) - expect(client.unsupported).to be(true) - expect(Datadog.logger).to have_received(:debug).with( - 'Agent does not support telemetry; disabling future telemetry events.' - ) - end - end - context 'when in fork' do before { skip 'Fork not supported on current platform' unless Process.respond_to?(:fork) } diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index 0a874112993..b2000f502a3 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -8,11 +8,13 @@ end let(:enabled) { true } - let(:heartbeat_interval_seconds) { 1.2 } + let(:heartbeat_interval_seconds) { 0.5 } let(:emitter) { double(Datadog::Core::Telemetry::Emitter) } before do - allow(emitter).to receive(:request) + logger = double(Datadog::Core::Logger) + allow(logger).to receive(:debug).with(any_args) + allow(Datadog).to receive(:logger).and_return(logger) end after do @@ -24,7 +26,7 @@ it 'creates a new worker in stopped state' do expect(worker).to have_attributes( enabled?: true, - loop_base_interval: 1.2, # seconds + loop_base_interval: heartbeat_interval_seconds, run_async?: false, running?: false, started?: false @@ -34,19 +36,75 @@ describe '#start' do context 'when enabled' do - it 'starts the worker and sends heartbeat event' do - worker.start + let(:response) do + double(Datadog::Core::Telemetry::Http::Adapters::Net::Response, not_found?: !backend_supports_telemetry?) + end + + before do + expect(emitter).to receive(:request) + .with(an_instance_of(Datadog::Core::Telemetry::Event::AppStarted)) + .and_return(response) + end + + context "when backend doesn't support telemetry" do + let(:backend_supports_telemetry?) { false } + + it 'disables the worker' do + worker.start + + try_wait_until { worker.sent_started_event? } + + expect(worker).to have_attributes( + enabled?: false, + loop_base_interval: heartbeat_interval_seconds, + ) + expect(Datadog.logger).to have_received(:debug).with( + 'Agent does not support telemetry; disabling future telemetry events.' + ) + end + end + + context 'when backend supports telemetry' do + let(:backend_supports_telemetry?) { true } + + it 'starts the worker and sends heartbeat event' do + expect(emitter).to receive(:request) + .with(an_instance_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) + + worker.start + + try_wait_until { worker.sent_started_event? } + + expect(worker).to have_attributes( + enabled?: true, + loop_base_interval: heartbeat_interval_seconds, + run_async?: true, + running?: true, + started?: true + ) + end + + it 'always sends heartbeat event after started event' do + @sent_hearbeat = false + allow(emitter).to receive(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) do + # app-started was already sent by now + expect(worker.sent_started_event?).to be(true) + + @sent_hearbeat = true + + response + end + + worker.start + + try_wait_until { @sent_hearbeat } + end + end - try_wait_until { worker.running? } + context 'when internal error returned by emitter' do + let(:response) { Datadog::Core::Telemetry::Http::InternalErrorResponse.new('error') } - expect(worker).to have_attributes( - enabled?: true, - loop_base_interval: 1.2, # seconds - run_async?: true, - running?: true, - started?: true - ) - expect(emitter).to have_received(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) + it { expect { worker.start }.to_not raise_error } end end From ca1d9ae3b3fb37ec772197c17c3ddbd4a1babd6e Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 14 Jun 2024 10:38:59 +0200 Subject: [PATCH 06/49] fix failing tests by waiting for worker startup --- lib/datadog/core/workers/polling.rb | 1 - spec/datadog/core/telemetry/worker_spec.rb | 16 +++++++++++++++- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/lib/datadog/core/workers/polling.rb b/lib/datadog/core/workers/polling.rb index ab2c5057083..fd516f16f79 100644 --- a/lib/datadog/core/workers/polling.rb +++ b/lib/datadog/core/workers/polling.rb @@ -22,7 +22,6 @@ def perform(*args) end def stop(force_stop = false, timeout = DEFAULT_SHUTDOWN_TIMEOUT) - # p "in stop" if running? # Attempt graceful stop and wait stop_loop diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index b2000f502a3..66dd3ebb416 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -104,7 +104,21 @@ context 'when internal error returned by emitter' do let(:response) { Datadog::Core::Telemetry::Http::InternalErrorResponse.new('error') } - it { expect { worker.start }.to_not raise_error } + it do + expect do + worker.start + + try_wait_until { worker.sent_started_event? } + + expect(worker).to have_attributes( + enabled?: true, + loop_base_interval: heartbeat_interval_seconds, + run_async?: true, + running?: true, + started?: true + ) + end.to_not raise_error + end end end From 1e5b92dc657278026895296a533c2a92d71de53f Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 14 Jun 2024 10:59:36 +0200 Subject: [PATCH 07/49] debug logging, flushing events, attempt at fixing failing test for worker --- lib/datadog/core/telemetry/worker.rb | 28 +++++++++++++++++++--- sig/datadog/core/telemetry/worker.rbs | 4 ++++ spec/datadog/core/telemetry/worker_spec.rb | 3 +++ 3 files changed, 32 insertions(+), 3 deletions(-) diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index 9ff7702e747..4e7ca78936e 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -38,7 +38,7 @@ def sent_started_event? private - def perform(*_events) + def perform(*events) return if !enabled? || forked? unless @sent_started_event @@ -47,20 +47,42 @@ def perform(*_events) end heartbeat! + + send_events(events) + end + + def send_events(events) + return unless enabled? + + Datadog.logger.debug { "Sending #{events&.count} telemetry events" } + (events || []).each do |event| + send_event(event) + end end def heartbeat! - @emitter.request(Event::AppHeartbeat.new) + return unless enabled? + + send_event(Event::AppHeartbeat.new) end def started! - res = @emitter.request(Event::AppStarted.new) + return unless enabled? + + res = send_event(Event::AppStarted.new) if res.not_found? # Telemetry is only supported by agent versions 7.34 and up Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.') self.enabled = false end end + + def send_event(event) + Datadog.logger.debug { "Sending telemetry event: #{event}" } + response = @emitter.request(event) + Datadog.logger.debug { "Received response: #{response}" } + response + end end end end diff --git a/sig/datadog/core/telemetry/worker.rbs b/sig/datadog/core/telemetry/worker.rbs index e1c5c09cf70..e8855724a6d 100644 --- a/sig/datadog/core/telemetry/worker.rbs +++ b/sig/datadog/core/telemetry/worker.rbs @@ -22,6 +22,10 @@ module Datadog def heartbeat!: () -> void def started!: () -> void + + def send_events: (Array[Event::Base] events) -> void + + def send_event: (Event::Base event) -> Datadog::Core::Telemetry::Http::Adapters::Net::Response end end end diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index 66dd3ebb416..0f4d9919e9a 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -105,6 +105,9 @@ let(:response) { Datadog::Core::Telemetry::Http::InternalErrorResponse.new('error') } it do + expect(emitter).to receive(:request) + .with(an_instance_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) + expect do worker.start From 95142d975b1713dc8aa23087ab514630ab879d10 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 14 Jun 2024 11:34:25 +0200 Subject: [PATCH 08/49] don't send heartbeat event if started event wasn't successfully sent --- lib/datadog/core/telemetry/worker.rb | 18 ++++---- sig/datadog/core/telemetry/worker.rbs | 2 +- spec/datadog/core/telemetry/worker_spec.rb | 50 +++++++++++----------- 3 files changed, 37 insertions(+), 33 deletions(-) diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index 4e7ca78936e..a837259c3f9 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -41,18 +41,15 @@ def sent_started_event? def perform(*events) return if !enabled? || forked? - unless @sent_started_event - started! - @sent_started_event = true - end + started! unless sent_started_event? heartbeat! - send_events(events) + flush_events(events) end - def send_events(events) - return unless enabled? + def flush_events(events) + return if !enabled? || !sent_started_event? Datadog.logger.debug { "Sending #{events&.count} telemetry events" } (events || []).each do |event| @@ -61,7 +58,7 @@ def send_events(events) end def heartbeat! - return unless enabled? + return if !enabled? || !sent_started_event? send_event(Event::AppHeartbeat.new) end @@ -75,6 +72,11 @@ def started! Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.') self.enabled = false end + + if res.ok? + Datadog.logger.debug('Telemetry app-started event is successfully sent') + @sent_started_event = true + end end def send_event(event) diff --git a/sig/datadog/core/telemetry/worker.rbs b/sig/datadog/core/telemetry/worker.rbs index e8855724a6d..64b3de884d3 100644 --- a/sig/datadog/core/telemetry/worker.rbs +++ b/sig/datadog/core/telemetry/worker.rbs @@ -23,7 +23,7 @@ module Datadog def started!: () -> void - def send_events: (Array[Event::Base] events) -> void + def flush_events: (Array[Event::Base] events) -> void def send_event: (Event::Base event) -> Datadog::Core::Telemetry::Http::Adapters::Net::Response end diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index 0f4d9919e9a..8b8aba31784 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -37,13 +37,28 @@ describe '#start' do context 'when enabled' do let(:response) do - double(Datadog::Core::Telemetry::Http::Adapters::Net::Response, not_found?: !backend_supports_telemetry?) + double( + Datadog::Core::Telemetry::Http::Adapters::Net::Response, + not_found?: !backend_supports_telemetry?, + ok?: backend_supports_telemetry? + ) end before do - expect(emitter).to receive(:request) - .with(an_instance_of(Datadog::Core::Telemetry::Event::AppStarted)) - .and_return(response) + @received_started = false + @received_heartbeat = false + + allow(emitter).to receive(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppStarted)) do + @received_started = true + + response + end + + allow(emitter).to receive(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) do + @received_heartbeat = true + + response + end end context "when backend doesn't support telemetry" do @@ -52,7 +67,7 @@ it 'disables the worker' do worker.start - try_wait_until { worker.sent_started_event? } + try_wait_until { @received_started } expect(worker).to have_attributes( enabled?: false, @@ -61,6 +76,7 @@ expect(Datadog.logger).to have_received(:debug).with( 'Agent does not support telemetry; disabling future telemetry events.' ) + expect(@received_heartbeat).to be(false) end end @@ -68,12 +84,9 @@ let(:backend_supports_telemetry?) { true } it 'starts the worker and sends heartbeat event' do - expect(emitter).to receive(:request) - .with(an_instance_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) - worker.start - try_wait_until { worker.sent_started_event? } + try_wait_until { @received_heartbeat } expect(worker).to have_attributes( enabled?: true, @@ -104,23 +117,12 @@ context 'when internal error returned by emitter' do let(:response) { Datadog::Core::Telemetry::Http::InternalErrorResponse.new('error') } - it do - expect(emitter).to receive(:request) - .with(an_instance_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) - - expect do - worker.start + it 'does not send heartbeat event' do + worker.start - try_wait_until { worker.sent_started_event? } + try_wait_until { @received_started } - expect(worker).to have_attributes( - enabled?: true, - loop_base_interval: heartbeat_interval_seconds, - run_async?: true, - running?: true, - started?: true - ) - end.to_not raise_error + expect(@received_heartbeat).to be(false) end end end From 9719706cbdb00b6e7edcb299f671e403709ae30a Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 14 Jun 2024 11:42:22 +0200 Subject: [PATCH 09/49] fix client_spec --- spec/datadog/core/telemetry/client_spec.rb | 1 + 1 file changed, 1 insertion(+) diff --git a/spec/datadog/core/telemetry/client_spec.rb b/spec/datadog/core/telemetry/client_spec.rb index 8532ad80185..ed5d991feb7 100644 --- a/spec/datadog/core/telemetry/client_spec.rb +++ b/spec/datadog/core/telemetry/client_spec.rb @@ -22,6 +22,7 @@ allow(Datadog::Core::Telemetry::Emitter).to receive(:new).and_return(emitter) allow(emitter).to receive(:request).and_return(response) allow(response).to receive(:not_found?).and_return(not_found) + allow(response).to receive(:ok?).and_return(!not_found) end describe '#initialize' do From 07f1356ed96b3bfb5c75a8358679fb1ee3de373a Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 14 Jun 2024 13:41:01 +0200 Subject: [PATCH 10/49] enqueue events to be sent later by worker instead of sending them synchronously --- lib/datadog/core/configuration/components.rb | 3 +- lib/datadog/core/telemetry/client.rb | 14 +-- lib/datadog/core/telemetry/worker.rb | 37 +++++- sig/datadog/core/telemetry/client.rbs | 3 +- sig/datadog/core/telemetry/worker.rbs | 10 +- sig/datadog/core/workers/polling.rbs | 2 +- spec/datadog/core/telemetry/client_spec.rb | 117 ++++++++----------- spec/datadog/core/telemetry/worker_spec.rb | 69 +++++++---- 8 files changed, 148 insertions(+), 107 deletions(-) diff --git a/lib/datadog/core/configuration/components.rb b/lib/datadog/core/configuration/components.rb index 19716dc25f2..b72b73dfe54 100644 --- a/lib/datadog/core/configuration/components.rb +++ b/lib/datadog/core/configuration/components.rb @@ -165,8 +165,9 @@ def shutdown!(replacement = nil) unused_statsd = (old_statsd - (old_statsd & new_statsd)) unused_statsd.each(&:close) - telemetry.stop! + # enqueue closing event before stopping telemetry so it will be send out on shutdown telemetry.emit_closing! unless replacement + telemetry.stop! end end end diff --git a/lib/datadog/core/telemetry/client.rb b/lib/datadog/core/telemetry/client.rb index 07028e96ad5..05a96e39239 100644 --- a/lib/datadog/core/telemetry/client.rb +++ b/lib/datadog/core/telemetry/client.rb @@ -19,7 +19,6 @@ class Client # @param [Boolean] dependency_collection Whether to send the `app-dependencies-loaded` event def initialize(heartbeat_interval_seconds:, dependency_collection:, enabled: true) @enabled = enabled - @emitter = Emitter.new @stopped = false @started = false @dependency_collection = dependency_collection @@ -27,7 +26,7 @@ def initialize(heartbeat_interval_seconds:, dependency_collection:, enabled: tru @worker = Telemetry::Worker.new( enabled: @enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, - emitter: @emitter + emitter: Emitter.new ) end @@ -41,7 +40,7 @@ def started! @worker.start - @emitter.request(Event::AppDependenciesLoaded.new) if @dependency_collection + @worker.enqueue(Event::AppDependenciesLoaded.new) if @dependency_collection @started = true end @@ -49,27 +48,28 @@ def started! def emit_closing! return if !@enabled || forked? - @emitter.request(Event::AppClosing.new) + @worker.enqueue(Event::AppClosing.new) end def stop! return if @stopped - @worker.stop(true, 0) + # gracefully stop the worker and send leftover events + @worker.stop @stopped = true end def integrations_change! return if !@enabled || forked? - @emitter.request(Event::AppIntegrationsChange.new) + @worker.enqueue(Event::AppIntegrationsChange.new) end # Report configuration changes caused by Remote Configuration. def client_configuration_change!(changes) return if !@enabled || forked? - @emitter.request(Event::AppClientConfigurationChange.new(changes, 'remote_config')) + @worker.enqueue(Event::AppClientConfigurationChange.new(changes, 'remote_config')) end end end diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index a837259c3f9..93fccab9a6c 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -13,7 +13,15 @@ class Worker include Core::Workers::Queue include Core::Workers::Polling - def initialize(heartbeat_interval_seconds:, emitter:, enabled: true) + DEFAULT_BUFFER_MAX_SIZE = 1000 + + def initialize( + heartbeat_interval_seconds:, + emitter:, + enabled: true, + shutdown_timeout: Workers::Polling::DEFAULT_SHUTDOWN_TIMEOUT, + buffer_size: DEFAULT_BUFFER_MAX_SIZE + ) @emitter = emitter @sent_started_event = false @@ -23,6 +31,11 @@ def initialize(heartbeat_interval_seconds:, emitter:, enabled: true) # Workers::IntervalLoop settings self.loop_base_interval = heartbeat_interval_seconds self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP + + @shutdown_timeout = shutdown_timeout + @buffer_size = buffer_size + + self.buffer = buffer_klass.new(@buffer_size) end def start @@ -32,6 +45,16 @@ def start perform end + def stop(force_stop = false, timeout = @shutdown_timeout) + buffer.close if running? + + super + end + + def enqueue(event) + buffer.push(event) + end + def sent_started_event? @sent_started_event end @@ -85,6 +108,18 @@ def send_event(event) Datadog.logger.debug { "Received response: #{response}" } response end + + def dequeue + buffer.pop + end + + def buffer_klass + if Core::Environment::Ext::RUBY_ENGINE == 'ruby' + Core::Buffer::CRuby + else + Core::Buffer::ThreadSafe + end + end end end end diff --git a/sig/datadog/core/telemetry/client.rbs b/sig/datadog/core/telemetry/client.rbs index e1646cb1eb8..007050163a7 100644 --- a/sig/datadog/core/telemetry/client.rbs +++ b/sig/datadog/core/telemetry/client.rbs @@ -6,14 +6,13 @@ module Datadog @dependency_collection: bool @started: bool @stopped: bool - @emitter: Datadog::Core::Telemetry::Emitter @worker: Datadog::Core::Telemetry::Worker attr_reader enabled: bool include Core::Utils::Forking - def initialize: (heartbeat_interval_seconds: Numeric, dependency_collection: bool, enabled: bool) -> void + def initialize: (heartbeat_interval_seconds: Numeric, dependency_collection: bool, ?enabled: bool) -> void def disable!: () -> void diff --git a/sig/datadog/core/telemetry/worker.rbs b/sig/datadog/core/telemetry/worker.rbs index 64b3de884d3..9220dfeea09 100644 --- a/sig/datadog/core/telemetry/worker.rbs +++ b/sig/datadog/core/telemetry/worker.rbs @@ -8,15 +8,21 @@ module Datadog include Core::Workers::IntervalLoop include Core::Workers::Queue + DEFAULT_BUFFER_MAX_SIZE: 1000 + @emitter: Emitter @sent_started_event: bool + @shutdown_timeout: Integer + @buffer_size: Integer - def initialize: (?enabled: bool, heartbeat_interval_seconds: Numeric, emitter: Emitter) -> void + def initialize: (?enabled: bool, heartbeat_interval_seconds: Numeric, emitter: Emitter, ?shutdown_timeout: Integer, ?buffer_size: Integer) -> void def start: () -> void def sent_started_event?: () -> bool + def enqueue: (Event::Base event) -> void + private def heartbeat!: () -> void @@ -26,6 +32,8 @@ module Datadog def flush_events: (Array[Event::Base] events) -> void def send_event: (Event::Base event) -> Datadog::Core::Telemetry::Http::Adapters::Net::Response + + def buffer_klass: () -> untyped end end end diff --git a/sig/datadog/core/workers/polling.rbs b/sig/datadog/core/workers/polling.rbs index 7f4d8f9c55b..43c1360a92c 100644 --- a/sig/datadog/core/workers/polling.rbs +++ b/sig/datadog/core/workers/polling.rbs @@ -2,7 +2,7 @@ module Datadog module Core module Workers module Polling - SHUTDOWN_TIMEOUT: 1 + DEFAULT_SHUTDOWN_TIMEOUT: 1 def self.included: (Class | Module base) -> void diff --git a/spec/datadog/core/telemetry/client_spec.rb b/spec/datadog/core/telemetry/client_spec.rb index ed5d991feb7..2e1a0a34bcf 100644 --- a/spec/datadog/core/telemetry/client_spec.rb +++ b/spec/datadog/core/telemetry/client_spec.rb @@ -14,15 +14,15 @@ let(:enabled) { true } let(:heartbeat_interval_seconds) { 0 } let(:dependency_collection) { true } - let(:emitter) { double(Datadog::Core::Telemetry::Emitter) } - let(:response) { double(Datadog::Core::Telemetry::Http::Adapters::Net::Response) } + let(:worker) { double(Datadog::Core::Telemetry::Worker) } let(:not_found) { false } before do - allow(Datadog::Core::Telemetry::Emitter).to receive(:new).and_return(emitter) - allow(emitter).to receive(:request).and_return(response) - allow(response).to receive(:not_found?).and_return(not_found) - allow(response).to receive(:ok?).and_return(!not_found) + allow(Datadog::Core::Telemetry::Worker).to receive(:new).and_return(worker) + allow(worker).to receive(:start) + allow(worker).to receive(:enqueue) + allow(worker).to receive(:stop) + allow(worker).to receive(:"enabled=") end describe '#initialize' do @@ -62,6 +62,12 @@ end it { expect { client.disable! }.to change { client.enabled }.from(true).to(false) } + + it 'disables worker' do + client.disable! + + expect(worker).to have_received(:"enabled=").with(false) + end end describe '#started!' do @@ -75,7 +81,8 @@ let(:enabled) { false } it do started! - expect(emitter).to_not have_received(:request) + + expect(worker).to_not have_received(:start) end end @@ -84,13 +91,11 @@ context 'when dependency_collection is true' do it do - dependencies = double - allow(Datadog::Core::Telemetry::Event::AppDependenciesLoaded) - .to receive(:new).with(no_args).and_return(dependencies) - started! - expect(emitter).to have_received(:request).with(dependencies) + expect(worker).to have_received(:enqueue).with( + an_instance_of(Datadog::Core::Telemetry::Event::AppDependenciesLoaded) + ) end end @@ -98,13 +103,9 @@ let(:dependency_collection) { false } it do - dependencies = double - allow(Datadog::Core::Telemetry::Event::AppDependenciesLoaded) - .to receive(:new).with(no_args).and_return(dependencies) - started! - expect(emitter).to_not have_received(:request).with(dependencies) + expect(worker).not_to have_received(:enqueue) end end end @@ -115,8 +116,9 @@ it do client expect_in_fork do - expect(emitter).to_not receive(:request) client.started! + + expect(worker).to_not have_received(:start) end end end @@ -133,21 +135,20 @@ let(:enabled) { false } it do emit_closing! - expect(emitter).to_not have_received(:request) + + expect(worker).not_to have_received(:enqueue) end end context 'when enabled' do let(:enabled) { true } it do - double = double() - allow(Datadog::Core::Telemetry::Event::AppClosing).to receive(:new).with(no_args).and_return(double) - emit_closing! - expect(emitter).to have_received(:request).with(double) - end - it { is_expected.to be(response) } + expect(worker).to have_received(:enqueue).with( + an_instance_of(Datadog::Core::Telemetry::Event::AppClosing) + ) + end end context 'when in fork' do @@ -156,8 +157,9 @@ it do client expect_in_fork do - expect(emitter).to_not receive(:request) client.started! + + expect(worker).not_to have_received(:enqueue) end end end @@ -165,32 +167,12 @@ describe '#stop!' do subject(:stop!) { client.stop! } - let(:worker) { instance_double(Datadog::Core::Telemetry::Worker) } - - before do - allow(Datadog::Core::Telemetry::Worker).to receive(:new) - .with(enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, emitter: emitter) - .and_return(worker) - allow(worker).to receive(:start) - allow(worker).to receive(:stop) - end - context 'when disabled' do - let(:enabled) { false } - it 'does not raise error' do - stop! - end - end + it 'stops worker once' do + stop! + stop! - context 'when enabled' do - let(:enabled) { true } - - context 'when stop! has been called already' do - it 'does not raise error' do - stop! - stop! - end - end + expect(worker).to have_received(:stop).once end end @@ -205,21 +187,20 @@ let(:enabled) { false } it do integrations_change! - expect(emitter).to_not have_received(:request) + + expect(worker).not_to have_received(:enqueue) end end context 'when enabled' do let(:enabled) { true } it do - double = double() - allow(Datadog::Core::Telemetry::Event::AppIntegrationsChange).to receive(:new).with(no_args).and_return(double) - integrations_change! - expect(emitter).to have_received(:request).with(double) - end - it { is_expected.to be(response) } + expect(worker).to have_received(:enqueue).with( + an_instance_of(Datadog::Core::Telemetry::Event::AppIntegrationsChange) + ) + end end context 'when in fork' do @@ -228,8 +209,9 @@ it do client expect_in_fork do - expect(emitter).to_not receive(:request) client.started! + + expect(worker).not_to have_received(:enqueue) end end end @@ -247,24 +229,20 @@ let(:enabled) { false } it do client_configuration_change! - expect(emitter).to_not have_received(:request) + + expect(worker).not_to have_received(:enqueue) end end context 'when enabled' do let(:enabled) { true } it do - double = double() - allow(Datadog::Core::Telemetry::Event::AppClientConfigurationChange).to receive(:new).with( - changes, - 'remote_config' - ).and_return(double) - client_configuration_change! - expect(emitter).to have_received(:request).with(double) - end - it { is_expected.to be(response) } + expect(worker).to have_received(:enqueue).with( + an_instance_of(Datadog::Core::Telemetry::Event::AppClientConfigurationChange) + ) + end end context 'when in fork' do @@ -273,8 +251,9 @@ it do client expect_in_fork do - expect(emitter).to_not receive(:request) client.started! + + expect(worker).not_to have_received(:enqueue) end end end diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index 8b8aba31784..ba389c23801 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -11,10 +11,34 @@ let(:heartbeat_interval_seconds) { 0.5 } let(:emitter) { double(Datadog::Core::Telemetry::Emitter) } + let(:backend_supports_telemetry?) { true } + let(:response) do + double( + Datadog::Core::Telemetry::Http::Adapters::Net::Response, + not_found?: !backend_supports_telemetry?, + ok?: backend_supports_telemetry? + ) + end + before do logger = double(Datadog::Core::Logger) allow(logger).to receive(:debug).with(any_args) allow(Datadog).to receive(:logger).and_return(logger) + + @received_started = false + @received_heartbeat = false + + allow(emitter).to receive(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppStarted)) do + @received_started = true + + response + end + + allow(emitter).to receive(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) do + @received_heartbeat = true + + response + end end after do @@ -36,31 +60,6 @@ describe '#start' do context 'when enabled' do - let(:response) do - double( - Datadog::Core::Telemetry::Http::Adapters::Net::Response, - not_found?: !backend_supports_telemetry?, - ok?: backend_supports_telemetry? - ) - end - - before do - @received_started = false - @received_heartbeat = false - - allow(emitter).to receive(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppStarted)) do - @received_started = true - - response - end - - allow(emitter).to receive(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) do - @received_heartbeat = true - - response - end - end - context "when backend doesn't support telemetry" do let(:backend_supports_telemetry?) { false } @@ -137,4 +136,24 @@ end end end + + describe '#enqueue' do + it 'adds events to the buffer and flushes them later' do + events_received = 0 + allow(emitter).to receive(:request).with( + an_instance_of(Datadog::Core::Telemetry::Event::AppIntegrationsChange) + ) do + events_received += 1 + end + + worker.start + + events_sent = 3 + events_sent.times do + worker.enqueue(Datadog::Core::Telemetry::Event::AppIntegrationsChange.new) + end + + try_wait_until { events_received == events_sent } + end + end end From c05339226e548a302684c8136890869acec37371 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 14 Jun 2024 14:14:30 +0200 Subject: [PATCH 11/49] rename Telemetry::Client to Telemetry::Component to better reflect its purpose --- lib/datadog/core/configuration/components.rb | 4 +- .../telemetry/{client.rb => component.rb} | 3 +- lib/datadog/core/telemetry/worker.rb | 6 +- .../telemetry/{client.rbs => component.rbs} | 2 +- .../core/configuration/components_spec.rb | 18 +++--- spec/datadog/core/configuration_spec.rb | 20 +++---- .../{client_spec.rb => component_spec.rb} | 56 +++++++++---------- 7 files changed, 54 insertions(+), 55 deletions(-) rename lib/datadog/core/telemetry/{client.rb => component.rb} (98%) rename sig/datadog/core/telemetry/{client.rbs => component.rbs} (97%) rename spec/datadog/core/telemetry/{client_spec.rb => component_spec.rb} (82%) diff --git a/lib/datadog/core/configuration/components.rb b/lib/datadog/core/configuration/components.rb index b72b73dfe54..11e1bce6b78 100644 --- a/lib/datadog/core/configuration/components.rb +++ b/lib/datadog/core/configuration/components.rb @@ -4,7 +4,7 @@ require_relative '../diagnostics/health' require_relative '../logger' require_relative '../runtime/metrics' -require_relative '../telemetry/client' +require_relative '../telemetry/component' require_relative '../workers/runtime_metrics' require_relative '../remote/component' @@ -60,7 +60,7 @@ def build_telemetry(settings, agent_settings, logger) logger.debug { "Telemetry disabled. Agent network adapter not supported: #{agent_settings.adapter}" } end - Telemetry::Client.new( + Telemetry::Component.new( enabled: enabled, heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds, dependency_collection: settings.telemetry.dependency_collection diff --git a/lib/datadog/core/telemetry/client.rb b/lib/datadog/core/telemetry/component.rb similarity index 98% rename from lib/datadog/core/telemetry/client.rb rename to lib/datadog/core/telemetry/component.rb index 05a96e39239..6324f8ac795 100644 --- a/lib/datadog/core/telemetry/client.rb +++ b/lib/datadog/core/telemetry/component.rb @@ -9,7 +9,7 @@ module Datadog module Core module Telemetry # Telemetry entrypoint, coordinates sending telemetry events at various points in app lifecycle. - class Client + class Component attr_reader :enabled include Core::Utils::Forking @@ -39,7 +39,6 @@ def started! return if !@enabled || forked? @worker.start - @worker.enqueue(Event::AppDependenciesLoaded.new) if @dependency_collection @started = true diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index 93fccab9a6c..da0bc7dd455 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -94,11 +94,11 @@ def started! if res.not_found? # Telemetry is only supported by agent versions 7.34 and up Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.') self.enabled = false - end - - if res.ok? + elsif res.ok? Datadog.logger.debug('Telemetry app-started event is successfully sent') @sent_started_event = true + else + Datadog.logger.debug('Error sending telemetry app-started event, retry after heartbeat interval...') end end diff --git a/sig/datadog/core/telemetry/client.rbs b/sig/datadog/core/telemetry/component.rbs similarity index 97% rename from sig/datadog/core/telemetry/client.rbs rename to sig/datadog/core/telemetry/component.rbs index 007050163a7..614ac20d691 100644 --- a/sig/datadog/core/telemetry/client.rbs +++ b/sig/datadog/core/telemetry/component.rbs @@ -1,7 +1,7 @@ module Datadog module Core module Telemetry - class Client + class Component @enabled: bool @dependency_collection: bool @started: bool diff --git a/spec/datadog/core/configuration/components_spec.rb b/spec/datadog/core/configuration/components_spec.rb index 53c20609523..22f16239a59 100644 --- a/spec/datadog/core/configuration/components_spec.rb +++ b/spec/datadog/core/configuration/components_spec.rb @@ -7,7 +7,7 @@ require 'datadog/core/diagnostics/environment_logger' require 'datadog/core/diagnostics/health' require 'datadog/core/logger' -require 'datadog/core/telemetry/client' +require 'datadog/core/telemetry/component' require 'datadog/core/runtime/metrics' require 'datadog/core/workers/runtime_metrics' require 'datadog/statsd' @@ -33,7 +33,7 @@ let(:profiler_setup_task) { Datadog::Profiling.supported? ? instance_double(Datadog::Profiling::Tasks::Setup) : nil } let(:remote) { instance_double(Datadog::Core::Remote::Component, start: nil, shutdown!: nil) } - let(:telemetry) { instance_double(Datadog::Core::Telemetry::Client) } + let(:telemetry) { instance_double(Datadog::Core::Telemetry::Component) } let(:environment_logger_extra) { { hello: 123, world: '456' } } @@ -46,7 +46,7 @@ end allow(Datadog::Statsd).to receive(:new) { instance_double(Datadog::Statsd) } allow(Datadog::Core::Remote::Component).to receive(:new).and_return(remote) - allow(Datadog::Core::Telemetry::Client).to receive(:new).and_return(telemetry) + allow(Datadog::Core::Telemetry::Component).to receive(:new).and_return(telemetry) end around do |example| @@ -223,7 +223,7 @@ let(:logger) { instance_double(Logger) } context 'given settings' do - let(:telemetry_client) { instance_double(Datadog::Core::Telemetry::Client) } + let(:telemetry) { instance_double(Datadog::Core::Telemetry::Component) } let(:expected_options) do { enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, dependency_collection: dependency_collection } @@ -233,16 +233,16 @@ let(:dependency_collection) { true } before do - expect(Datadog::Core::Telemetry::Client).to receive(:new).with(expected_options).and_return(telemetry_client) + expect(Datadog::Core::Telemetry::Component).to receive(:new).with(expected_options).and_return(telemetry) allow(settings.telemetry).to receive(:enabled).and_return(enabled) end - it { is_expected.to be(telemetry_client) } + it { is_expected.to be(telemetry) } context 'with :enabled true' do let(:enabled) { double('enabled') } - it { is_expected.to be(telemetry_client) } + it { is_expected.to be(telemetry) } context 'and :unix agent adapter' do let(:expected_options) do @@ -255,7 +255,7 @@ it 'does not enable telemetry for unsupported non-http transport' do expect(logger).to receive(:debug) - is_expected.to be(telemetry_client) + is_expected.to be(telemetry) end end end @@ -1168,7 +1168,7 @@ let(:runtime_metrics) { instance_double(Datadog::Core::Runtime::Metrics, statsd: statsd) } let(:health_metrics) { instance_double(Datadog::Core::Diagnostics::Health::Metrics, statsd: statsd) } let(:statsd) { instance_double(::Datadog::Statsd) } - let(:telemetry) { instance_double(Datadog::Core::Telemetry::Client) } + let(:telemetry) { instance_double(Datadog::Core::Telemetry::Component) } before do allow(replacement).to receive(:tracer).and_return(tracer) diff --git a/spec/datadog/core/configuration_spec.rb b/spec/datadog/core/configuration_spec.rb index 46ded6049ff..469f5efd667 100644 --- a/spec/datadog/core/configuration_spec.rb +++ b/spec/datadog/core/configuration_spec.rb @@ -8,13 +8,13 @@ RSpec.describe Datadog::Core::Configuration do let(:default_log_level) { ::Logger::INFO } - let(:telemetry_client) { instance_double(Datadog::Core::Telemetry::Client) } + let(:telemetry) { instance_double(Datadog::Core::Telemetry::Component) } before do - allow(telemetry_client).to receive(:started!) - allow(telemetry_client).to receive(:stop!) - allow(telemetry_client).to receive(:emit_closing!) - allow(Datadog::Core::Telemetry::Client).to receive(:new).and_return(telemetry_client) + allow(telemetry).to receive(:started!) + allow(telemetry).to receive(:stop!) + allow(telemetry).to receive(:emit_closing!) + allow(Datadog::Core::Telemetry::Component).to receive(:new).and_return(telemetry) allow(Datadog::Core::Remote::Component).to receive(:build) end @@ -43,7 +43,7 @@ it do # We cannot mix `expect().to_not` with `expect().to(...).ordered`. # One way around that is to force the method to raise an error if it's ever called. - allow(telemetry_client).to receive(:started!).and_raise('Should not be called') + allow(telemetry).to receive(:started!).and_raise('Should not be called') # Components should have changed expect { configure } @@ -84,7 +84,7 @@ .with(test_class.configuration) expect(new_components).to_not have_received(:shutdown!) - expect(telemetry_client).to have_received(:started!) + expect(telemetry).to have_received(:started!) end end end @@ -501,7 +501,7 @@ describe '#components' do context 'when components are not initialized' do it 'initializes the components' do - expect(telemetry_client).to receive(:started!) + expect(telemetry).to receive(:started!) test_class.send(:components) @@ -510,7 +510,7 @@ context 'when allow_initialization is false' do it 'does not initialize the components' do - expect(telemetry_client).to_not receive(:started!) + expect(telemetry).to_not receive(:started!) test_class.send(:components, allow_initialization: false) @@ -527,7 +527,7 @@ it 'returns the components without touching the COMPONENTS_WRITE_LOCK' do described_class.const_get(:COMPONENTS_WRITE_LOCK).lock - expect(telemetry_client).to_not receive(:started!) + expect(telemetry).to_not receive(:started!) expect(test_class.send(:components)).to_not be_nil end end diff --git a/spec/datadog/core/telemetry/client_spec.rb b/spec/datadog/core/telemetry/component_spec.rb similarity index 82% rename from spec/datadog/core/telemetry/client_spec.rb rename to spec/datadog/core/telemetry/component_spec.rb index 2e1a0a34bcf..5d1f7f013f7 100644 --- a/spec/datadog/core/telemetry/client_spec.rb +++ b/spec/datadog/core/telemetry/component_spec.rb @@ -1,9 +1,9 @@ require 'spec_helper' -require 'datadog/core/telemetry/client' +require 'datadog/core/telemetry/component' -RSpec.describe Datadog::Core::Telemetry::Client do - subject(:client) do +RSpec.describe Datadog::Core::Telemetry::Component do + subject(:telemetry) do described_class.new( enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, @@ -27,11 +27,11 @@ describe '#initialize' do after do - client.stop! + telemetry.stop! end context 'with default parameters' do - subject(:client) do + subject(:telemetry) do described_class.new( heartbeat_interval_seconds: heartbeat_interval_seconds, dependency_collection: dependency_collection @@ -39,42 +39,42 @@ end it { is_expected.to be_a_kind_of(described_class) } - it { expect(client.enabled).to be(true) } + it { expect(telemetry.enabled).to be(true) } end context 'when :enabled is false' do let(:enabled) { false } it { is_expected.to be_a_kind_of(described_class) } - it { expect(client.enabled).to be(false) } + it { expect(telemetry.enabled).to be(false) } end context 'when enabled' do let(:enabled) { true } it { is_expected.to be_a_kind_of(described_class) } - it { expect(client.enabled).to be(true) } + it { expect(telemetry.enabled).to be(true) } end end describe '#disable!' do after do - client.stop! + telemetry.stop! end - it { expect { client.disable! }.to change { client.enabled }.from(true).to(false) } + it { expect { telemetry.disable! }.to change { telemetry.enabled }.from(true).to(false) } it 'disables worker' do - client.disable! + telemetry.disable! expect(worker).to have_received(:"enabled=").with(false) end end describe '#started!' do - subject(:started!) { client.started! } + subject(:started!) { telemetry.started! } after do - client.stop! + telemetry.stop! end context 'when disabled' do @@ -114,9 +114,9 @@ before { skip 'Fork not supported on current platform' unless Process.respond_to?(:fork) } it do - client + telemetry expect_in_fork do - client.started! + telemetry.started! expect(worker).to_not have_received(:start) end @@ -125,10 +125,10 @@ end describe '#emit_closing!' do - subject(:emit_closing!) { client.emit_closing! } + subject(:emit_closing!) { telemetry.emit_closing! } after do - client.stop! + telemetry.stop! end context 'when disabled' do @@ -155,9 +155,9 @@ before { skip 'Fork not supported on current platform' unless Process.respond_to?(:fork) } it do - client + telemetry expect_in_fork do - client.started! + telemetry.started! expect(worker).not_to have_received(:enqueue) end @@ -166,7 +166,7 @@ end describe '#stop!' do - subject(:stop!) { client.stop! } + subject(:stop!) { telemetry.stop! } it 'stops worker once' do stop! @@ -177,10 +177,10 @@ end describe '#integrations_change!' do - subject(:integrations_change!) { client.integrations_change! } + subject(:integrations_change!) { telemetry.integrations_change! } after do - client.stop! + telemetry.stop! end context 'when disabled' do @@ -207,9 +207,9 @@ before { skip 'Fork not supported on current platform' unless Process.respond_to?(:fork) } it do - client + telemetry expect_in_fork do - client.started! + telemetry.started! expect(worker).not_to have_received(:enqueue) end @@ -218,11 +218,11 @@ end describe '#client_configuration_change!' do - subject(:client_configuration_change!) { client.client_configuration_change!(changes) } + subject(:client_configuration_change!) { telemetry.client_configuration_change!(changes) } let(:changes) { double('changes') } after do - client.stop! + telemetry.stop! end context 'when disabled' do @@ -249,9 +249,9 @@ before { skip 'Fork not supported on current platform' unless Process.respond_to?(:fork) } it do - client + telemetry expect_in_fork do - client.started! + telemetry.started! expect(worker).not_to have_received(:enqueue) end From 0ad3d8247dfa82ebfb77260d912e17f294acd065 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 14 Jun 2024 14:24:44 +0200 Subject: [PATCH 12/49] leftover of telemetry component rename --- spec/datadog/tracing/contrib/extensions_spec.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spec/datadog/tracing/contrib/extensions_spec.rb b/spec/datadog/tracing/contrib/extensions_spec.rb index 92f2c8b2e5a..f95238b24ea 100644 --- a/spec/datadog/tracing/contrib/extensions_spec.rb +++ b/spec/datadog/tracing/contrib/extensions_spec.rb @@ -46,7 +46,7 @@ end it 'sends a telemetry integrations change event' do - expect_any_instance_of(Datadog::Core::Telemetry::Client).to receive(:integrations_change!) + expect_any_instance_of(Datadog::Core::Telemetry::Component).to receive(:integrations_change!) configure end end From 253fd4fd05b1017507495144e401d9d062ceefa1 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Mon, 17 Jun 2024 12:37:58 +0200 Subject: [PATCH 13/49] add Core::Utils::OnlyOnceSuccessful to execute code with only one success --- .../core/utils/only_once_successful.rb | 34 +++++++ sig/datadog/core/utils/only_once.rbs | 3 + .../core/utils/only_once_successful.rbs | 8 ++ .../core/utils/only_once_successful_spec.rb | 95 +++++++++++++++++++ 4 files changed, 140 insertions(+) create mode 100644 lib/datadog/core/utils/only_once_successful.rb create mode 100644 sig/datadog/core/utils/only_once_successful.rbs create mode 100644 spec/datadog/core/utils/only_once_successful_spec.rb diff --git a/lib/datadog/core/utils/only_once_successful.rb b/lib/datadog/core/utils/only_once_successful.rb new file mode 100644 index 00000000000..e5ac05d304b --- /dev/null +++ b/lib/datadog/core/utils/only_once_successful.rb @@ -0,0 +1,34 @@ +# frozen_string_literal: true + +require_relative 'only_once' + +module Datadog + module Core + module Utils + # Helper class to execute something with only one success. + # + # This is useful for cases where we want to ensure that a block of code is only executed once, and only if it + # succeeds. One such example is sending app-started telemetry event. + # + # Successful execution is determined by the return value of the block: any truthy value is considered success. + # + # Thread-safe when used correctly (e.g. be careful of races when lazily initializing instances of this class). + # + # Note: In its current state, this class is not Ractor-safe. + # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives, + # including an alternative implementation that is Ractor-safe once spent. + class OnlyOnceSuccessful < OnlyOnce + def run + @mutex.synchronize do + return if @ran_once + + result = yield + @ran_once = !!result + + result + end + end + end + end + end +end diff --git a/sig/datadog/core/utils/only_once.rbs b/sig/datadog/core/utils/only_once.rbs index 324b1ba72e7..354334c71e1 100644 --- a/sig/datadog/core/utils/only_once.rbs +++ b/sig/datadog/core/utils/only_once.rbs @@ -2,6 +2,9 @@ module Datadog module Core module Utils class OnlyOnce + @ran_once: bool + @mutex: Thread::Mutex + def initialize: () -> untyped def run: () { () -> untyped } -> untyped diff --git a/sig/datadog/core/utils/only_once_successful.rbs b/sig/datadog/core/utils/only_once_successful.rbs new file mode 100644 index 00000000000..81d24fc9094 --- /dev/null +++ b/sig/datadog/core/utils/only_once_successful.rbs @@ -0,0 +1,8 @@ +module Datadog + module Core + module Utils + class OnlyOnceSuccessful < Datadog::Core::Utils::OnlyOnce + end + end + end +end diff --git a/spec/datadog/core/utils/only_once_successful_spec.rb b/spec/datadog/core/utils/only_once_successful_spec.rb new file mode 100644 index 00000000000..bf06ff5d60c --- /dev/null +++ b/spec/datadog/core/utils/only_once_successful_spec.rb @@ -0,0 +1,95 @@ +require 'datadog/core/utils/only_once_successful' + +RSpec.describe Datadog::Core::Utils::OnlyOnceSuccessful do + subject(:only_once_successful) { described_class.new } + + describe '#run' do + context 'before running once' do + it do + expect { |block| only_once_successful.run(&block) }.to yield_control + end + + it 'returns the result of the block ran' do + expect(only_once_successful.run { :result }).to be :result + end + end + + context 'after running once' do + let(:result) { nil } + + before do + only_once_successful.run { result } + end + + context 'when block returns truthy value' do + let(:result) { true } + + it do + expect { |block| only_once_successful.run(&block) }.to_not yield_control + end + + it do + expect(only_once_successful.run { :result }).to be nil + end + end + + context 'when block returns falsey value' do + let(:result) { false } + + it do + expect { |block| only_once_successful.run(&block) }.to yield_control + end + + it 'runs again until block returns truthy value' do + expect(only_once_successful.run { :result }).to be :result + + expect(only_once_successful.run { :result }).to be nil + end + end + end + + context 'when run throws an exception' do + it 'propagates the exception out' do + exception = RuntimeError.new('boom') + + expect { only_once_successful.run { raise exception } }.to raise_exception(exception) + end + + it 'runs again' do + only_once_successful.run { raise 'boom' } rescue nil + + expect { |block| only_once_successful.run(&block) }.to yield_control + end + end + end + + describe '#ran?' do + context 'before running once' do + it do + expect(only_once_successful.ran?).to be false + end + end + + context 'after running once' do + let(:result) { nil } + + before do + only_once_successful.run { result } + end + + context 'when block returns truthy value' do + let(:result) { true } + + it do + expect(only_once_successful.ran?).to be true + end + end + + context 'when block returns falsey value' do + it do + expect(only_once_successful.ran?).to be false + end + end + end + end +end From 7c8d15444a44131d12ffa9eb7be777df56f38b3e Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Mon, 17 Jun 2024 14:09:57 +0200 Subject: [PATCH 14/49] ensure that app-started event is sent at most once, flush events before stopping worker --- lib/datadog/core/telemetry/component.rb | 17 ++-- lib/datadog/core/telemetry/worker.rb | 43 ++++++---- sig/datadog/core/telemetry/worker.rbs | 5 ++ spec/datadog/core/telemetry/component_spec.rb | 4 +- spec/datadog/core/telemetry/worker_spec.rb | 78 ++++++++++++++++++- 5 files changed, 116 insertions(+), 31 deletions(-) diff --git a/lib/datadog/core/telemetry/component.rb b/lib/datadog/core/telemetry/component.rb index 6324f8ac795..f457a434ce4 100644 --- a/lib/datadog/core/telemetry/component.rb +++ b/lib/datadog/core/telemetry/component.rb @@ -28,6 +28,7 @@ def initialize(heartbeat_interval_seconds:, dependency_collection:, enabled: tru heartbeat_interval_seconds: heartbeat_interval_seconds, emitter: Emitter.new ) + @worker.start end def disable! @@ -38,26 +39,24 @@ def disable! def started! return if !@enabled || forked? - @worker.start @worker.enqueue(Event::AppDependenciesLoaded.new) if @dependency_collection @started = true end - def emit_closing! - return if !@enabled || forked? - - @worker.enqueue(Event::AppClosing.new) - end - def stop! return if @stopped - # gracefully stop the worker and send leftover events - @worker.stop + @worker.stop(true) @stopped = true end + def emit_closing! + return if !@enabled || forked? + + @worker.enqueue(Event::AppClosing.new) + end + def integrations_change! return if !@enabled || forked? diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index da0bc7dd455..8ba8e8723b1 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -2,6 +2,7 @@ require_relative 'event' +require_relative '../utils/only_once_successful' require_relative '../workers/polling' require_relative '../workers/queue' @@ -15,6 +16,8 @@ class Worker DEFAULT_BUFFER_MAX_SIZE = 1000 + TELEMETRY_STARTED_ONCE = Utils::OnlyOnceSuccessful.new + def initialize( heartbeat_interval_seconds:, emitter:, @@ -24,8 +27,6 @@ def initialize( ) @emitter = emitter - @sent_started_event = false - # Workers::Polling settings self.enabled = enabled # Workers::IntervalLoop settings @@ -48,6 +49,8 @@ def start def stop(force_stop = false, timeout = @shutdown_timeout) buffer.close if running? + flush_events(dequeue) if work_pending? + super end @@ -56,7 +59,7 @@ def enqueue(event) end def sent_started_event? - @sent_started_event + TELEMETRY_STARTED_ONCE.ran? end private @@ -89,24 +92,25 @@ def heartbeat! def started! return unless enabled? - res = send_event(Event::AppStarted.new) + TELEMETRY_STARTED_ONCE.run do + res = send_event(Event::AppStarted.new) - if res.not_found? # Telemetry is only supported by agent versions 7.34 and up - Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.') - self.enabled = false - elsif res.ok? - Datadog.logger.debug('Telemetry app-started event is successfully sent') - @sent_started_event = true - else - Datadog.logger.debug('Error sending telemetry app-started event, retry after heartbeat interval...') + if res.ok? + Datadog.logger.debug('Telemetry app-started event is successfully sent') + true + else + Datadog.logger.debug('Error sending telemetry app-started event, retry after heartbeat interval...') + false + end end end def send_event(event) - Datadog.logger.debug { "Sending telemetry event: #{event}" } - response = @emitter.request(event) - Datadog.logger.debug { "Received response: #{response}" } - response + res = @emitter.request(event) + + disable_on_not_found!(res) + + res end def dequeue @@ -120,6 +124,13 @@ def buffer_klass Core::Buffer::ThreadSafe end end + + def disable_on_not_found!(response) + return unless response.not_found? + + Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.') + self.enabled = false + end end end end diff --git a/sig/datadog/core/telemetry/worker.rbs b/sig/datadog/core/telemetry/worker.rbs index 9220dfeea09..b804a19664d 100644 --- a/sig/datadog/core/telemetry/worker.rbs +++ b/sig/datadog/core/telemetry/worker.rbs @@ -8,6 +8,7 @@ module Datadog include Core::Workers::IntervalLoop include Core::Workers::Queue + TELEMETRY_STARTED_ONCE: Datadog::Core::Utils::OnlyOnceSuccessful DEFAULT_BUFFER_MAX_SIZE: 1000 @emitter: Emitter @@ -23,6 +24,8 @@ module Datadog def enqueue: (Event::Base event) -> void + def dequeue: () -> Array[Event::Base] + private def heartbeat!: () -> void @@ -33,6 +36,8 @@ module Datadog def send_event: (Event::Base event) -> Datadog::Core::Telemetry::Http::Adapters::Net::Response + def disable_on_not_found!: (Datadog::Core::Telemetry::Http::Adapters::Net::Response response) -> void + def buffer_klass: () -> untyped end end diff --git a/spec/datadog/core/telemetry/component_spec.rb b/spec/datadog/core/telemetry/component_spec.rb index 5d1f7f013f7..33f4544ec6e 100644 --- a/spec/datadog/core/telemetry/component_spec.rb +++ b/spec/datadog/core/telemetry/component_spec.rb @@ -82,7 +82,7 @@ it do started! - expect(worker).to_not have_received(:start) + expect(worker).to_not have_received(:enqueue) end end @@ -118,7 +118,7 @@ expect_in_fork do telemetry.started! - expect(worker).to_not have_received(:start) + expect(worker).to_not have_received(:enqueue) end end end diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index ba389c23801..6008cefd892 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -42,8 +42,10 @@ end after do - worker.stop(true, 0) + worker.stop(true) worker.join + + Datadog::Core::Telemetry::Worker::TELEMETRY_STARTED_ONCE.send(:reset_ran_once_state_for_tests) end describe '.new' do @@ -97,19 +99,19 @@ end it 'always sends heartbeat event after started event' do - @sent_hearbeat = false + sent_hearbeat = false allow(emitter).to receive(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) do # app-started was already sent by now expect(worker.sent_started_event?).to be(true) - @sent_hearbeat = true + sent_hearbeat = true response end worker.start - try_wait_until { @sent_hearbeat } + try_wait_until { sent_hearbeat } end end @@ -124,6 +126,42 @@ expect(@received_heartbeat).to be(false) end end + + context 'several workers running' do + it 'sends single started event' do + started_events = 0 + allow(emitter).to receive(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppStarted)) do + started_events += 1 + + response + end + + heartbeat_events = 0 + allow(emitter).to receive(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) do + heartbeat_events += 1 + + response + end + + workers = Array.new(3) do + described_class.new( + enabled: enabled, + heartbeat_interval_seconds: heartbeat_interval_seconds, + emitter: emitter + ) + end + workers.each(&:start) + + try_wait_until { heartbeat_events >= 3 } + + expect(started_events).to be(1) + + workers.each do |w| + w.stop(true, 0) + w.join + end + end + end end context 'when disabled' do @@ -137,6 +175,36 @@ end end + describe '#stop' do + let(:heartbeat_interval_seconds) { 3 } + + it 'flushes events and stops the worker' do + events_received = 0 + allow(emitter).to receive(:request).with( + an_instance_of(Datadog::Core::Telemetry::Event::AppIntegrationsChange) + ) do + events_received += 1 + + response + end + + worker.start + + worker.enqueue(Datadog::Core::Telemetry::Event::AppIntegrationsChange.new) + worker.stop(true) + + try_wait_until { !worker.running? } + + expect(worker).to have_attributes( + enabled?: true, + loop_base_interval: heartbeat_interval_seconds, + run_async?: false, + running?: false, + started?: true + ) + end + end + describe '#enqueue' do it 'adds events to the buffer and flushes them later' do events_received = 0 @@ -144,6 +212,8 @@ an_instance_of(Datadog::Core::Telemetry::Event::AppIntegrationsChange) ) do events_received += 1 + + response end worker.start From 9498ebc062c7714892b5b9adbfcb1f218f1c31e0 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Mon, 17 Jun 2024 16:04:27 +0200 Subject: [PATCH 15/49] remove Telemetry::Component.started! as right now it just contains dependency collection event logic, move it to the Worker --- lib/datadog/core/configuration.rb | 19 ++---- lib/datadog/core/telemetry/component.rb | 13 +--- lib/datadog/core/telemetry/worker.rb | 5 ++ sig/datadog/core/telemetry/component.rbs | 4 -- sig/datadog/core/telemetry/worker.rbs | 3 +- spec/datadog/core/configuration_spec.rb | 11 --- spec/datadog/core/telemetry/component_spec.rb | 68 ++----------------- spec/datadog/core/telemetry/worker_spec.rb | 31 ++++++++- 8 files changed, 51 insertions(+), 103 deletions(-) diff --git a/lib/datadog/core/configuration.rb b/lib/datadog/core/configuration.rb index 9ecb6e1c837..5ff0343a775 100644 --- a/lib/datadog/core/configuration.rb +++ b/lib/datadog/core/configuration.rb @@ -81,23 +81,16 @@ def configure configuration = self.configuration yield(configuration) - built_components = false - - components = safely_synchronize do |write_components| + safely_synchronize do |write_components| write_components.call( if components? replace_components!(configuration, @components) else - components = build_components(configuration) - built_components = true - components + build_components(configuration) end ) end - # Should only be called the first time components are built - components.telemetry.started! if built_components - configuration end @@ -197,20 +190,20 @@ def components(allow_initialization: true) current_components = COMPONENTS_READ_LOCK.synchronize { defined?(@components) && @components } return current_components if current_components || !allow_initialization - built_components = false - - components = safely_synchronize do |write_components| + safely_synchronize do |write_components| if defined?(@components) && @components @components else - built_components = true write_components.call(build_components(configuration)) end end +<<<<<<< HEAD # Should only be called the first time components are built components.telemetry.started! if built_components && components && components.telemetry components +======= +>>>>>>> 69adca124 (remove Telemetry::Component.started! as right now it just contains dependency collection event logic, move it to the Worker) end private diff --git a/lib/datadog/core/telemetry/component.rb b/lib/datadog/core/telemetry/component.rb index f457a434ce4..0d5046e4391 100644 --- a/lib/datadog/core/telemetry/component.rb +++ b/lib/datadog/core/telemetry/component.rb @@ -20,13 +20,12 @@ class Component def initialize(heartbeat_interval_seconds:, dependency_collection:, enabled: true) @enabled = enabled @stopped = false - @started = false - @dependency_collection = dependency_collection @worker = Telemetry::Worker.new( enabled: @enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, - emitter: Emitter.new + emitter: Emitter.new, + dependency_collection: dependency_collection ) @worker.start end @@ -36,14 +35,6 @@ def disable! @worker.enabled = false end - def started! - return if !@enabled || forked? - - @worker.enqueue(Event::AppDependenciesLoaded.new) if @dependency_collection - - @started = true - end - def stop! return if @stopped diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index 8ba8e8723b1..f2bd7821b4c 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -21,11 +21,13 @@ class Worker def initialize( heartbeat_interval_seconds:, emitter:, + dependency_collection:, enabled: true, shutdown_timeout: Workers::Polling::DEFAULT_SHUTDOWN_TIMEOUT, buffer_size: DEFAULT_BUFFER_MAX_SIZE ) @emitter = emitter + @dependency_collection = dependency_collection # Workers::Polling settings self.enabled = enabled @@ -97,6 +99,9 @@ def started! if res.ok? Datadog.logger.debug('Telemetry app-started event is successfully sent') + + enqueue(Event::AppDependenciesLoaded.new) if @dependency_collection + true else Datadog.logger.debug('Error sending telemetry app-started event, retry after heartbeat interval...') diff --git a/sig/datadog/core/telemetry/component.rbs b/sig/datadog/core/telemetry/component.rbs index 614ac20d691..4d411d32578 100644 --- a/sig/datadog/core/telemetry/component.rbs +++ b/sig/datadog/core/telemetry/component.rbs @@ -3,8 +3,6 @@ module Datadog module Telemetry class Component @enabled: bool - @dependency_collection: bool - @started: bool @stopped: bool @worker: Datadog::Core::Telemetry::Worker @@ -18,8 +16,6 @@ module Datadog def client_configuration_change!: (Enumerable[[String, Numeric | bool | String]] changes) -> void - def started!: () -> void - def emit_closing!: () -> void def stop!: () -> void diff --git a/sig/datadog/core/telemetry/worker.rbs b/sig/datadog/core/telemetry/worker.rbs index b804a19664d..01c5107e990 100644 --- a/sig/datadog/core/telemetry/worker.rbs +++ b/sig/datadog/core/telemetry/worker.rbs @@ -15,8 +15,9 @@ module Datadog @sent_started_event: bool @shutdown_timeout: Integer @buffer_size: Integer + @dependency_collection: bool - def initialize: (?enabled: bool, heartbeat_interval_seconds: Numeric, emitter: Emitter, ?shutdown_timeout: Integer, ?buffer_size: Integer) -> void + def initialize: (?enabled: bool, heartbeat_interval_seconds: Numeric, emitter: Emitter, ?shutdown_timeout: Integer, ?buffer_size: Integer, dependency_collection: bool) -> void def start: () -> void diff --git a/spec/datadog/core/configuration_spec.rb b/spec/datadog/core/configuration_spec.rb index 469f5efd667..3ea7605c877 100644 --- a/spec/datadog/core/configuration_spec.rb +++ b/spec/datadog/core/configuration_spec.rb @@ -11,7 +11,6 @@ let(:telemetry) { instance_double(Datadog::Core::Telemetry::Component) } before do - allow(telemetry).to receive(:started!) allow(telemetry).to receive(:stop!) allow(telemetry).to receive(:emit_closing!) allow(Datadog::Core::Telemetry::Component).to receive(:new).and_return(telemetry) @@ -41,10 +40,6 @@ end it do - # We cannot mix `expect().to_not` with `expect().to(...).ordered`. - # One way around that is to force the method to raise an error if it's ever called. - allow(telemetry).to receive(:started!).and_raise('Should not be called') - # Components should have changed expect { configure } .to change { test_class.send(:components) } @@ -84,7 +79,6 @@ .with(test_class.configuration) expect(new_components).to_not have_received(:shutdown!) - expect(telemetry).to have_received(:started!) end end end @@ -501,8 +495,6 @@ describe '#components' do context 'when components are not initialized' do it 'initializes the components' do - expect(telemetry).to receive(:started!) - test_class.send(:components) expect(test_class.send(:components?)).to be true @@ -510,8 +502,6 @@ context 'when allow_initialization is false' do it 'does not initialize the components' do - expect(telemetry).to_not receive(:started!) - test_class.send(:components, allow_initialization: false) expect(test_class.send(:components?)).to be false @@ -527,7 +517,6 @@ it 'returns the components without touching the COMPONENTS_WRITE_LOCK' do described_class.const_get(:COMPONENTS_WRITE_LOCK).lock - expect(telemetry).to_not receive(:started!) expect(test_class.send(:components)).to_not be_nil end end diff --git a/spec/datadog/core/telemetry/component_spec.rb b/spec/datadog/core/telemetry/component_spec.rb index 33f4544ec6e..ba17d37c2f4 100644 --- a/spec/datadog/core/telemetry/component_spec.rb +++ b/spec/datadog/core/telemetry/component_spec.rb @@ -18,7 +18,13 @@ let(:not_found) { false } before do - allow(Datadog::Core::Telemetry::Worker).to receive(:new).and_return(worker) + allow(Datadog::Core::Telemetry::Worker).to receive(:new).with( + heartbeat_interval_seconds: heartbeat_interval_seconds, + dependency_collection: dependency_collection, + enabled: enabled, + emitter: an_instance_of(Datadog::Core::Telemetry::Emitter) + ).and_return(worker) + allow(worker).to receive(:start) allow(worker).to receive(:enqueue) allow(worker).to receive(:stop) @@ -70,60 +76,6 @@ end end - describe '#started!' do - subject(:started!) { telemetry.started! } - - after do - telemetry.stop! - end - - context 'when disabled' do - let(:enabled) { false } - it do - started! - - expect(worker).to_not have_received(:enqueue) - end - end - - context 'when enabled' do - let(:enabled) { true } - - context 'when dependency_collection is true' do - it do - started! - - expect(worker).to have_received(:enqueue).with( - an_instance_of(Datadog::Core::Telemetry::Event::AppDependenciesLoaded) - ) - end - end - - context 'when dependency_collection is false' do - let(:dependency_collection) { false } - - it do - started! - - expect(worker).not_to have_received(:enqueue) - end - end - end - - context 'when in fork' do - before { skip 'Fork not supported on current platform' unless Process.respond_to?(:fork) } - - it do - telemetry - expect_in_fork do - telemetry.started! - - expect(worker).to_not have_received(:enqueue) - end - end - end - end - describe '#emit_closing!' do subject(:emit_closing!) { telemetry.emit_closing! } @@ -157,8 +109,6 @@ it do telemetry expect_in_fork do - telemetry.started! - expect(worker).not_to have_received(:enqueue) end end @@ -209,8 +159,6 @@ it do telemetry expect_in_fork do - telemetry.started! - expect(worker).not_to have_received(:enqueue) end end @@ -251,8 +199,6 @@ it do telemetry expect_in_fork do - telemetry.started! - expect(worker).not_to have_received(:enqueue) end end diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index 6008cefd892..6a1d5ca055f 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -4,12 +4,18 @@ RSpec.describe Datadog::Core::Telemetry::Worker do subject(:worker) do - described_class.new(enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, emitter: emitter) + described_class.new( + enabled: enabled, + heartbeat_interval_seconds: heartbeat_interval_seconds, + emitter: emitter, + dependency_collection: dependency_collection + ) end let(:enabled) { true } let(:heartbeat_interval_seconds) { 0.5 } let(:emitter) { double(Datadog::Core::Telemetry::Emitter) } + let(:dependency_collection) { false } let(:backend_supports_telemetry?) { true } let(:response) do @@ -113,6 +119,26 @@ try_wait_until { sent_hearbeat } end + + context 'when dependencies collection enabled' do + let(:dependency_collection) { true } + + it 'sends dependencies loaded event after started event' do + sent_dependencies = false + allow(emitter).to receive(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppDependenciesLoaded)) do + # app-started was already sent by now + expect(worker.sent_started_event?).to be(true) + + sent_dependencies = true + + response + end + + worker.start + + try_wait_until { sent_dependencies } + end + end end context 'when internal error returned by emitter' do @@ -147,7 +173,8 @@ described_class.new( enabled: enabled, heartbeat_interval_seconds: heartbeat_interval_seconds, - emitter: emitter + emitter: emitter, + dependency_collection: dependency_collection ) end workers.each(&:start) From 5347a092c51eaa0d9bfe57679f53a4cc81ac8a06 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Mon, 17 Jun 2024 16:12:35 +0200 Subject: [PATCH 16/49] change the wrong expectation in workers spec --- spec/datadog/core/telemetry/worker_spec.rb | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index 6a1d5ca055f..ad5885abca8 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -222,13 +222,7 @@ try_wait_until { !worker.running? } - expect(worker).to have_attributes( - enabled?: true, - loop_base_interval: heartbeat_interval_seconds, - run_async?: false, - running?: false, - started?: true - ) + expect(events_received).to eq(1) end end From 32f1208e9e8e0affaf30920046f3e3d9062b410d Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Mon, 17 Jun 2024 16:48:53 +0200 Subject: [PATCH 17/49] send app-dependencies-loaded event right after app-started event in the same thread --- lib/datadog/core/telemetry/worker.rb | 2 +- spec/datadog/core/telemetry/worker_spec.rb | 18 +++--------------- 2 files changed, 4 insertions(+), 16 deletions(-) diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index f2bd7821b4c..2021e139b0a 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -100,7 +100,7 @@ def started! if res.ok? Datadog.logger.debug('Telemetry app-started event is successfully sent') - enqueue(Event::AppDependenciesLoaded.new) if @dependency_collection + send_event(Event::AppDependenciesLoaded.new) if @dependency_collection true else diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index ad5885abca8..35a01e46834 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -127,7 +127,8 @@ sent_dependencies = false allow(emitter).to receive(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppDependenciesLoaded)) do # app-started was already sent by now - expect(worker.sent_started_event?).to be(true) + # don't use worker.sent_started_event? because it uses the same lock + expect(@received_started).to be(true) sent_dependencies = true @@ -206,23 +207,10 @@ let(:heartbeat_interval_seconds) { 3 } it 'flushes events and stops the worker' do - events_received = 0 - allow(emitter).to receive(:request).with( - an_instance_of(Datadog::Core::Telemetry::Event::AppIntegrationsChange) - ) do - events_received += 1 - - response - end - worker.start - worker.enqueue(Datadog::Core::Telemetry::Event::AppIntegrationsChange.new) + expect(worker).to receive(:flush_events).at_least(:once) worker.stop(true) - - try_wait_until { !worker.running? } - - expect(events_received).to eq(1) end end From b9ed222d32ff28248a072935fa06ec4b8f2ec9fa Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 21 Jun 2024 09:48:03 +0200 Subject: [PATCH 18/49] add limit option to OnlyOnceSuccessful util --- .../core/utils/only_once_successful.rb | 34 ++++ .../core/utils/only_once_successful.rbs | 15 ++ .../core/utils/only_once_successful_spec.rb | 176 ++++++++++++++++-- 3 files changed, 206 insertions(+), 19 deletions(-) diff --git a/lib/datadog/core/utils/only_once_successful.rb b/lib/datadog/core/utils/only_once_successful.rb index e5ac05d304b..4209cafc1ef 100644 --- a/lib/datadog/core/utils/only_once_successful.rb +++ b/lib/datadog/core/utils/only_once_successful.rb @@ -18,6 +18,14 @@ module Utils # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives, # including an alternative implementation that is Ractor-safe once spent. class OnlyOnceSuccessful < OnlyOnce + def initialize(limit = 0) + super() + + @limit = limit + @failed = false + @retries = 0 + end + def run @mutex.synchronize do return if @ran_once @@ -25,9 +33,35 @@ def run result = yield @ran_once = !!result + if !@ran_once && limited? + @retries += 1 + check_limit! + end + result end end + + def success? + @mutex.synchronize { @ran_once && !@failed } + end + + def failed? + @mutex.synchronize { @ran_once && @failed } + end + + private + + def check_limit! + if @retries >= @limit + @failed = true + @ran_once = true + end + end + + def limited? + !@limit.nil? && @limit.positive? + end end end end diff --git a/sig/datadog/core/utils/only_once_successful.rbs b/sig/datadog/core/utils/only_once_successful.rbs index 81d24fc9094..2236b5a66b5 100644 --- a/sig/datadog/core/utils/only_once_successful.rbs +++ b/sig/datadog/core/utils/only_once_successful.rbs @@ -2,6 +2,21 @@ module Datadog module Core module Utils class OnlyOnceSuccessful < Datadog::Core::Utils::OnlyOnce + @limit: Integer + @retries: Integer + @failed: bool + + def initialize: (?Integer limit) -> void + + def success?: () -> bool + + def failed?: () -> bool + + private + + def check_limit!: () -> void + + def limited?: () -> bool end end end diff --git a/spec/datadog/core/utils/only_once_successful_spec.rb b/spec/datadog/core/utils/only_once_successful_spec.rb index bf06ff5d60c..e0adb31b41a 100644 --- a/spec/datadog/core/utils/only_once_successful_spec.rb +++ b/spec/datadog/core/utils/only_once_successful_spec.rb @@ -1,28 +1,62 @@ require 'datadog/core/utils/only_once_successful' RSpec.describe Datadog::Core::Utils::OnlyOnceSuccessful do - subject(:only_once_successful) { described_class.new } + subject(:only_once_successful) { described_class.new(limit) } + + let(:limit) { 0 } describe '#run' do - context 'before running once' do - it do - expect { |block| only_once_successful.run(&block) }.to yield_control - end + context 'when limitless' do + context 'before running once' do + it do + expect { |block| only_once_successful.run(&block) }.to yield_control + end - it 'returns the result of the block ran' do - expect(only_once_successful.run { :result }).to be :result + it 'returns the result of the block ran' do + expect(only_once_successful.run { :result }).to be :result + end end - end - context 'after running once' do - let(:result) { nil } + context 'after running once' do + let(:result) { nil } - before do - only_once_successful.run { result } + before do + only_once_successful.run { result } + end + + context 'when block returns truthy value' do + let(:result) { true } + + it do + expect { |block| only_once_successful.run(&block) }.to_not yield_control + end + + it do + expect(only_once_successful.run { :result }).to be nil + end + end + + context 'when block returns falsey value' do + let(:result) { false } + + it do + expect { |block| only_once_successful.run(&block) }.to yield_control + end + + it 'runs again until block returns truthy value' do + expect(only_once_successful.run { :result }).to be :result + + expect(only_once_successful.run { :result }).to be nil + end + end end + end + + context 'when limited' do + let(:limit) { 2 } context 'when block returns truthy value' do - let(:result) { true } + before { only_once_successful.run { true } } it do expect { |block| only_once_successful.run(&block) }.to_not yield_control @@ -33,16 +67,18 @@ end end - context 'when block returns falsey value' do - let(:result) { false } + context 'when block returns falsey value "limit" times' do + before do + limit.times do + only_once_successful.run { false } + end + end it do - expect { |block| only_once_successful.run(&block) }.to yield_control + expect { |block| only_once_successful.run(&block) }.to_not yield_control end - it 'runs again until block returns truthy value' do - expect(only_once_successful.run { :result }).to be :result - + it do expect(only_once_successful.run { :result }).to be nil end end @@ -91,5 +127,107 @@ end end end + + context 'when limited and ran "limit" times' do + let(:limit) { 2 } + + before do + limit.times do + only_once_successful.run { false } + end + end + + it do + expect(only_once_successful.ran?).to be true + end + end + end + + describe '#success?' do + context 'before running once' do + it do + expect(only_once_successful.success?).to be false + end + end + + context 'after running once' do + let(:result) { nil } + + before do + only_once_successful.run { result } + end + + context 'when block returns truthy value' do + let(:result) { true } + + it do + expect(only_once_successful.success?).to be true + end + end + + context 'when block returns falsey value' do + it do + expect(only_once_successful.success?).to be false + end + end + end + + context 'when limited and ran "limit" times' do + let(:limit) { 2 } + + before do + limit.times do + only_once_successful.run { false } + end + end + + it do + expect(only_once_successful.success?).to be false + end + end + end + + describe '#failed?' do + context 'before running once' do + it do + expect(only_once_successful.failed?).to be false + end + end + + context 'after running once' do + let(:result) { nil } + + before do + only_once_successful.run { result } + end + + context 'when block returns truthy value' do + let(:result) { true } + + it do + expect(only_once_successful.failed?).to be false + end + end + + context 'when block returns falsey value' do + it do + expect(only_once_successful.failed?).to be false + end + end + end + + context 'when limited and ran "limit" times' do + let(:limit) { 2 } + + before do + limit.times do + only_once_successful.run { false } + end + end + + it do + expect(only_once_successful.failed?).to be true + end + end end end From 929316af62e648855d025eb369ebb594a359644c Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 21 Jun 2024 10:37:14 +0200 Subject: [PATCH 19/49] limit telemetry app-started event retries --- lib/datadog/core/telemetry/worker.rb | 15 ++++- .../core/utils/only_once_successful.rb | 8 +++ sig/datadog/core/telemetry/worker.rbs | 3 + spec/datadog/core/telemetry/worker_spec.rb | 65 +++++++++++++++++++ 4 files changed, 89 insertions(+), 2 deletions(-) diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index 2021e139b0a..46d7721ee40 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -15,8 +15,9 @@ class Worker include Core::Workers::Polling DEFAULT_BUFFER_MAX_SIZE = 1000 + APP_STARTED_EVENT_RETRIES = 10 - TELEMETRY_STARTED_ONCE = Utils::OnlyOnceSuccessful.new + TELEMETRY_STARTED_ONCE = Utils::OnlyOnceSuccessful.new(APP_STARTED_EVENT_RETRIES) def initialize( heartbeat_interval_seconds:, @@ -61,7 +62,11 @@ def enqueue(event) end def sent_started_event? - TELEMETRY_STARTED_ONCE.ran? + TELEMETRY_STARTED_ONCE.success? + end + + def failed_to_start? + TELEMETRY_STARTED_ONCE.failed? end private @@ -94,6 +99,12 @@ def heartbeat! def started! return unless enabled? + if failed_to_start? + Datadog.logger.debug('Telemetry app-started event exhausted retries, disabling telemetry worker') + self.enabled = false + return + end + TELEMETRY_STARTED_ONCE.run do res = send_event(Event::AppStarted.new) diff --git a/lib/datadog/core/utils/only_once_successful.rb b/lib/datadog/core/utils/only_once_successful.rb index 4209cafc1ef..ed8b4141963 100644 --- a/lib/datadog/core/utils/only_once_successful.rb +++ b/lib/datadog/core/utils/only_once_successful.rb @@ -62,6 +62,14 @@ def check_limit! def limited? !@limit.nil? && @limit.positive? end + + def reset_ran_once_state_for_tests + @mutex.synchronize do + @ran_once = false + @failed = false + @retries = 0 + end + end end end end diff --git a/sig/datadog/core/telemetry/worker.rbs b/sig/datadog/core/telemetry/worker.rbs index 01c5107e990..822b9fece95 100644 --- a/sig/datadog/core/telemetry/worker.rbs +++ b/sig/datadog/core/telemetry/worker.rbs @@ -9,6 +9,7 @@ module Datadog include Core::Workers::Queue TELEMETRY_STARTED_ONCE: Datadog::Core::Utils::OnlyOnceSuccessful + APP_STARTED_EVENT_RETRIES: 10 DEFAULT_BUFFER_MAX_SIZE: 1000 @emitter: Emitter @@ -23,6 +24,8 @@ module Datadog def sent_started_event?: () -> bool + def failed_to_start?: () -> bool + def enqueue: (Event::Base event) -> void def dequeue: () -> Array[Event::Base] diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index 35a01e46834..e73fec0888e 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -120,6 +120,71 @@ try_wait_until { sent_hearbeat } end + context 'when app-started event fails' do + it 'retries' do + expect(emitter).to receive(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppStarted)) + .and_return( + double( + Datadog::Core::Telemetry::Http::Adapters::Net::Response, + not_found?: false, + ok?: false + ) + ).once + + expect(emitter).to receive(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppStarted)) do + @received_started = true + + response + end + + sent_hearbeat = false + allow(emitter).to receive(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) do + # app-started was already sent by now + expect(@received_started).to be(true) + + sent_hearbeat = true + + response + end + + worker.start + + try_wait_until { sent_hearbeat } + end + end + + context 'when app-started event exhausted retries' do + let(:heartbeat_interval_seconds) { 0.1 } + + it 'stops retrying, never sends heartbeat, and disables worker' do + expect(emitter).to receive(:request).with(an_instance_of(Datadog::Core::Telemetry::Event::AppStarted)) + .and_return( + double( + Datadog::Core::Telemetry::Http::Adapters::Net::Response, + not_found?: false, + ok?: false + ) + ).exactly(described_class::APP_STARTED_EVENT_RETRIES).times + + sent_hearbeat = false + allow(emitter).to receive(:request).with(kind_of(Datadog::Core::Telemetry::Event::AppHeartbeat)) do + # app-started was already sent by now + expect(@received_started).to be(true) + + sent_hearbeat = true + + response + end + + worker.start + + try_wait_until { !worker.enabled? } + + expect(sent_hearbeat).to be(false) + expect(worker.failed_to_start?).to be(true) + end + end + context 'when dependencies collection enabled' do let(:dependency_collection) { true } From 53f11eae26253aab46ee1c526c60a39240efcb51 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 21 Jun 2024 10:56:40 +0200 Subject: [PATCH 20/49] do not instantiate empty array every time when sending events --- lib/datadog/core/telemetry/worker.rb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index 46d7721ee40..ed1ce11f0d8 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -82,10 +82,11 @@ def perform(*events) end def flush_events(events) + return if events.nil? return if !enabled? || !sent_started_event? Datadog.logger.debug { "Sending #{events&.count} telemetry events" } - (events || []).each do |event| + events.each do |event| send_event(event) end end From 098d19800d2c6e3aa3add10fbab4d9f81dfd40c8 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Tue, 25 Jun 2024 12:19:11 +0200 Subject: [PATCH 21/49] lower HTTP timeout for telemetry worker --- lib/datadog/core/telemetry/http/adapters/net.rb | 2 +- lib/datadog/core/telemetry/worker.rb | 2 ++ sig/datadog/core/telemetry/http/adapters/net.rbs | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/lib/datadog/core/telemetry/http/adapters/net.rb b/lib/datadog/core/telemetry/http/adapters/net.rb index faca410b973..06eb07a80d3 100644 --- a/lib/datadog/core/telemetry/http/adapters/net.rb +++ b/lib/datadog/core/telemetry/http/adapters/net.rb @@ -13,7 +13,7 @@ class Net :timeout, :ssl - DEFAULT_TIMEOUT = 30 + DEFAULT_TIMEOUT = 2 def initialize(hostname:, port: nil, timeout: DEFAULT_TIMEOUT, ssl: true) @hostname = hostname diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index ed1ce11f0d8..57633251ac7 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -58,6 +58,8 @@ def stop(force_stop = false, timeout = @shutdown_timeout) end def enqueue(event) + return if !enabled? || forked? + buffer.push(event) end diff --git a/sig/datadog/core/telemetry/http/adapters/net.rbs b/sig/datadog/core/telemetry/http/adapters/net.rbs index 5cf50e53adf..311c5989f95 100644 --- a/sig/datadog/core/telemetry/http/adapters/net.rbs +++ b/sig/datadog/core/telemetry/http/adapters/net.rbs @@ -14,7 +14,7 @@ module Datadog attr_reader ssl: bool - DEFAULT_TIMEOUT: 30 + DEFAULT_TIMEOUT: 2 def initialize: (hostname: String, ?port: Integer?, ?timeout: Float | Integer, ?ssl: bool?) -> void From df0f8f824e336b215f3e10e8ee2e50ead51cad95 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Wed, 26 Jun 2024 12:46:12 +0200 Subject: [PATCH 22/49] remove merge artifacts --- lib/datadog/core/configuration.rb | 7 ------- 1 file changed, 7 deletions(-) diff --git a/lib/datadog/core/configuration.rb b/lib/datadog/core/configuration.rb index 5ff0343a775..f2d76a6114f 100644 --- a/lib/datadog/core/configuration.rb +++ b/lib/datadog/core/configuration.rb @@ -197,13 +197,6 @@ def components(allow_initialization: true) write_components.call(build_components(configuration)) end end -<<<<<<< HEAD - - # Should only be called the first time components are built - components.telemetry.started! if built_components && components && components.telemetry - components -======= ->>>>>>> 69adca124 (remove Telemetry::Component.started! as right now it just contains dependency collection event logic, move it to the Worker) end private From 3c42a260cfba19e8be56bcd7306cc7e27cf00beb Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Wed, 26 Jun 2024 13:02:33 +0200 Subject: [PATCH 23/49] minor fix for older rubies --- lib/datadog/core/telemetry/worker.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index 57633251ac7..f19a324704a 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -87,7 +87,7 @@ def flush_events(events) return if events.nil? return if !enabled? || !sent_started_event? - Datadog.logger.debug { "Sending #{events&.count} telemetry events" } + Datadog.logger.debug { "Sending #{events.count} telemetry events" } events.each do |event| send_event(event) end From e71b3a110f4a389ef7d057512abb9a42a69b8ed1 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Wed, 26 Jun 2024 13:10:05 +0200 Subject: [PATCH 24/49] ignore ethon and httprb for jruby --- Rakefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rakefile b/Rakefile index 9384c608290..d091756c94e 100644 --- a/Rakefile +++ b/Rakefile @@ -76,7 +76,7 @@ TEST_METADATA = { 'elasticsearch-8' => '❌ 2.1 / ❌ 2.2 / ❌ 2.3 / ❌ 2.4 / ✅ 2.5 / ✅ 2.6 / ✅ 2.7 / ✅ 3.0 / ✅ 3.1 / ✅ 3.2 / ✅ 3.3 / ✅ jruby' }, 'ethon' => { - 'http' => '✅ 2.1 / ✅ 2.2 / ✅ 2.3 / ✅ 2.4 / ✅ 2.5 / ✅ 2.6 / ✅ 2.7 / ✅ 3.0 / ✅ 3.1 / ✅ 3.2 / ✅ 3.3 / ✅ jruby' + 'http' => '✅ 2.1 / ✅ 2.2 / ✅ 2.3 / ✅ 2.4 / ✅ 2.5 / ✅ 2.6 / ✅ 2.7 / ✅ 3.0 / ✅ 3.1 / ✅ 3.2 / ✅ 3.3 / ❌ jruby' }, 'excon' => { 'http' => '✅ 2.1 / ✅ 2.2 / ✅ 2.3 / ✅ 2.4 / ✅ 2.5 / ✅ 2.6 / ✅ 2.7 / ✅ 3.0 / ✅ 3.1 / ✅ 3.2 / ✅ 3.3 / ✅ jruby' @@ -111,7 +111,7 @@ TEST_METADATA = { 'http' => '✅ 2.1 / ✅ 2.2 / ✅ 2.3 / ✅ 2.4 / ✅ 2.5 / ✅ 2.6 / ✅ 2.7 / ✅ 3.0 / ✅ 3.1 / ✅ 3.2 / ✅ 3.3 / ✅ jruby' }, 'httprb' => { - 'http' => '✅ 2.1 / ✅ 2.2 / ✅ 2.3 / ✅ 2.4 / ✅ 2.5 / ✅ 2.6 / ✅ 2.7 / ✅ 3.0 / ✅ 3.1 / ✅ 3.2 / ✅ 3.3 / ✅ jruby' + 'http' => '✅ 2.1 / ✅ 2.2 / ✅ 2.3 / ✅ 2.4 / ✅ 2.5 / ✅ 2.6 / ✅ 2.7 / ✅ 3.0 / ✅ 3.1 / ✅ 3.2 / ✅ 3.3 / ❌ jruby' }, 'kafka' => { 'activesupport' => '✅ 2.1 / ✅ 2.2 / ✅ 2.3 / ✅ 2.4 / ✅ 2.5 / ✅ 2.6 / ✅ 2.7 / ✅ 3.0 / ✅ 3.1 / ✅ 3.2 / ✅ 3.3 / ✅ jruby' From fdfc830f622ead9a970c290f8f9fc9cad7a6c425 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Wed, 26 Jun 2024 14:52:25 +0200 Subject: [PATCH 25/49] positive? does not exist on older rubies --- lib/datadog/core/utils/only_once_successful.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/datadog/core/utils/only_once_successful.rb b/lib/datadog/core/utils/only_once_successful.rb index ed8b4141963..3f854b424e7 100644 --- a/lib/datadog/core/utils/only_once_successful.rb +++ b/lib/datadog/core/utils/only_once_successful.rb @@ -60,7 +60,7 @@ def check_limit! end def limited? - !@limit.nil? && @limit.positive? + !@limit.nil? && @limit > 0 end def reset_ran_once_state_for_tests From 1a86a2f1266ca611ecb782febbe5b57bd502d2a4 Mon Sep 17 00:00:00 2001 From: Marco Costa Date: Tue, 18 Jun 2024 16:23:21 -0700 Subject: [PATCH 26/49] chore(lib-injection): update base image to alpine 3.20 --- lib-injection/Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib-injection/Dockerfile b/lib-injection/Dockerfile index 65e97a6c867..8e45d3ca19c 100644 --- a/lib-injection/Dockerfile +++ b/lib-injection/Dockerfile @@ -1,6 +1,6 @@ # This image provides the files needed to install the dd-trace-rb # and auto instrument Ruby applications in containerized environments. -FROM alpine:3.18.3 +FROM alpine:3.20 # Set high UID to prevent possible conflict with existing users: http://www.linfo.org/uid.html ARG UID=10000 From 07fd511a962d53ada45c5bc27a6dc87861481a6a Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Tue, 18 Jun 2024 18:10:57 +0200 Subject: [PATCH 27/49] Add post_install_message in gemspec --- ddtrace.gemspec | 11 +++++++++++ spec/ddtrace/release_gem_spec.rb | 6 ++++++ 2 files changed, 17 insertions(+) diff --git a/ddtrace.gemspec b/ddtrace.gemspec index 61581894f08..7d0b782dbcf 100644 --- a/ddtrace.gemspec +++ b/ddtrace.gemspec @@ -75,4 +75,15 @@ Gem::Specification.new do |spec| spec.add_dependency 'datadog-ci', '~> 0.8.1' spec.extensions = ['ext/datadog_profiling_native_extension/extconf.rb', 'ext/datadog_profiling_loader/extconf.rb'] + + spec.post_install_message = <<-MSG + Thank you for installing ddtrace. + + As of version 2, the `ddtrace` gem has been renamed to `datadog` to better represent the full suite of Datadog products. + The 1.x series will now only receive maintenance updates for security and critical bug fixes. + + To upgrade, please update your Gemfile to replace `ddtrace` with `datadog`. + + For detailed instructions on migration, see: https://github.com/DataDog/dd-trace-rb/blob/master/docs/UpgradeGuide2.md + MSG end diff --git a/spec/ddtrace/release_gem_spec.rb b/spec/ddtrace/release_gem_spec.rb index 90a89a8df51..450a247289d 100644 --- a/spec/ddtrace/release_gem_spec.rb +++ b/spec/ddtrace/release_gem_spec.rb @@ -131,5 +131,11 @@ end end end + + describe '#post_install_message' do + it do + expect(gemspec.post_install_message).to_not be_nil + end + end end end From 0a86bc449547ae9e2438d512a7a4c8d85cb99521 Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Tue, 18 Jun 2024 18:11:45 +0200 Subject: [PATCH 28/49] Update unreleasec comparison in changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 278f3717e4b..76192e0c435 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2826,7 +2826,7 @@ 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.23.2...master +[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.2...1.x-stable [1.23.2]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.1...v1.23.2 [1.23.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.0...v1.23.1 [1.23.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.22.0...v1.23.0 From 176641186a89c0eba537aa8e621f26e79481c6d1 Mon Sep 17 00:00:00 2001 From: Baptiste Foy Date: Thu, 13 Jun 2024 14:24:28 +0200 Subject: [PATCH 29/49] backport(OCI): Backport OCI build in 1.x --- .gitlab-ci.yml | 54 +++++++++++++++++++++++++++++++++++- .gitlab/build-oci-package.sh | 19 +++++++++++++ .gitlab/onboarding_tests.yml | 3 +- 3 files changed, 74 insertions(+), 2 deletions(-) create mode 100755 .gitlab/build-oci-package.sh diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 430de7a9c30..e68fed81440 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -149,10 +149,59 @@ package-arm64: - export RUBY_PACKAGE_VERSION=$(cat ../tmp/version.txt) - ../.gitlab/build-deb-rpm.sh +package-oci-amd64: + extends: .package-oci + stage: package + needs: + - build-gem + - install-dependencies-amd64 + variables: + ARCH: amd64 + script: + - cp ../lib-injection/host_inject.rb ../tmp + - export RUBY_PACKAGE_VERSION=$(cat ../tmp/version.txt) + - ../.gitlab/build-oci-package.sh + +package-oci-arm64: + extends: .package-oci + stage: package + needs: + - build-gem + - install-dependencies-arm64 + variables: + ARCH: arm64 + script: + - cp ../lib-injection/host_inject.rb ../tmp + - export RUBY_PACKAGE_VERSION=$(cat ../tmp/version.txt) + - ../.gitlab/build-oci-package.sh + +oci-internal-publish: + extends: .oci-internal-publish + stage: package + needs: [ package-oci-arm64, package-oci-amd64 ] + rules: + - when: on_success + variables: + FLAVOR: datadog-apm-library-ruby + +oci-internal-test-ecr-publish: + stage: package + needs: [ oci-internal-publish ] + rules: + - when: on_success + trigger: + project: DataDog/public-images + branch: main + strategy: depend + variables: + IMG_SOURCES: registry.ddbuild.io/ci/remote-updates/datadog-apm-library-ruby:pipeline-${CI_PIPELINE_ID}-1 + IMG_DESTINATIONS: apm-library-ruby-package:pipeline-${CI_PIPELINE_ID} + IMG_REGISTRIES: agent-qa + onboarding_tests: extends: .base_job_onboarding_tests stage: integration-tests - needs: [ package-amd64, package-arm64] + needs: [ package-amd64, package-arm64, oci-internal-test-ecr-publish] allow_failure: false variables: TEST_LIBRARY: ruby @@ -163,10 +212,13 @@ onboarding_tests: SCENARIO: [SIMPLE_HOST_AUTO_INJECTION] - ONBOARDING_FILTER_WEBLOG: [test-app-ruby-container] SCENARIO: [SIMPLE_CONTAINER_AUTO_INJECTION] + - ONBOARDING_FILTER_WEBLOG: [test-app-ruby,test-app-ruby-container] + SCENARIO: [INSTALLER_AUTO_INJECTION] script: - git clone https://git@github.com/DataDog/system-tests.git system-tests - cp packaging/*.rpm system-tests/binaries - cp packaging/*.deb system-tests/binaries + - export DD_INSTALLER_LIBRARY_VERSION="pipeline-${CI_PIPELINE_ID}" - ls system-tests/binaries - cd system-tests - ./build.sh -i runner diff --git a/.gitlab/build-oci-package.sh b/.gitlab/build-oci-package.sh new file mode 100755 index 00000000000..268e25d700c --- /dev/null +++ b/.gitlab/build-oci-package.sh @@ -0,0 +1,19 @@ +#!/bin/bash + +set -e + +mkdir sources + +cp -r ../tmp/* sources +sed -i "s#/opt/datadog/apm/library/ruby/#/opt/datadog-packages/datadog-apm-library-ruby/$RUBY_PACKAGE_VERSION/#g" sources/host_inject.rb + +echo -n "$RUBY_PACKAGE_VERSION" > sources/version + +datadog-package create \ + --version="$RUBY_PACKAGE_VERSION" \ + --package="datadog-apm-library-ruby" \ + --archive=true \ + --archive-path="datadog-apm-library-ruby-$RUBY_PACKAGE_VERSION-$ARCH.tar" \ + --arch "$ARCH" \ + --os "linux" \ + ./sources diff --git a/.gitlab/onboarding_tests.yml b/.gitlab/onboarding_tests.yml index 73a1dad76bc..1ad4471659a 100644 --- a/.gitlab/onboarding_tests.yml +++ b/.gitlab/onboarding_tests.yml @@ -10,6 +10,7 @@ - export DD_APP_KEY_ONBOARDING=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.dd-app-key-onboarding --with-decryption --query "Parameter.Value" --out text) - export ONBOARDING_AWS_INFRA_SUBNET_ID=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.aws-infra-subnet-id --with-decryption --query "Parameter.Value" --out text) - export ONBOARDING_AWS_INFRA_SECURITY_GROUPS_ID=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.aws-infra-securiy-groups-id --with-decryption --query "Parameter.Value" --out text) + - export ONBOARDING_AWS_INFRA_IAM_INSTANCE_PROFILE=ec2InstanceRole - export PULUMI_CONFIG_PASSPHRASE=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.pulumi-config-passphrase --with-decryption --query "Parameter.Value" --out text) #Install plugins for PULUMI you need connect to gh. Sometimes this problem arises: GitHub rate limit exceeded - export GITHUB_TOKEN=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.gh-token --with-decryption --query "Parameter.Value" --out text) @@ -30,4 +31,4 @@ artifacts: when: always paths: - - system-tests/reports/ \ No newline at end of file + - system-tests/reports/ From c06a2140c93c19e9e8403a27345d7483c38a0bda Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 28 Jun 2024 11:32:11 +0200 Subject: [PATCH 30/49] fix deadlock issue: don't flush_events in main thread when calling stop, override #work_pending? instead --- lib/datadog/core/telemetry/worker.rb | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index f19a324704a..f4f65a5186f 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -52,8 +52,6 @@ def start def stop(force_stop = false, timeout = @shutdown_timeout) buffer.close if running? - flush_events(dequeue) if work_pending? - super end @@ -136,6 +134,10 @@ def dequeue buffer.pop end + def work_pending? + @run_loop || !buffer.empty? + end + def buffer_klass if Core::Environment::Ext::RUBY_ENGINE == 'ruby' Core::Buffer::CRuby From 6c5399b9389bc66e0016f9137975e18faf1b3f26 Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 28 Jun 2024 11:36:54 +0200 Subject: [PATCH 31/49] fix flaky test --- spec/datadog/core/telemetry/worker_spec.rb | 2 ++ 1 file changed, 2 insertions(+) diff --git a/spec/datadog/core/telemetry/worker_spec.rb b/spec/datadog/core/telemetry/worker_spec.rb index e73fec0888e..bc88ad63b38 100644 --- a/spec/datadog/core/telemetry/worker_spec.rb +++ b/spec/datadog/core/telemetry/worker_spec.rb @@ -275,6 +275,8 @@ worker.start expect(worker).to receive(:flush_events).at_least(:once) + + worker.enqueue(Datadog::Core::Telemetry::Event::AppIntegrationsChange.new) worker.stop(true) end end From 5a06b583474b1536beede20c019b468a5e8c39ae Mon Sep 17 00:00:00 2001 From: Andrey Marchenko Date: Fri, 28 Jun 2024 11:54:00 +0200 Subject: [PATCH 32/49] use method instead of instance variable --- lib/datadog/core/telemetry/worker.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/datadog/core/telemetry/worker.rb b/lib/datadog/core/telemetry/worker.rb index f4f65a5186f..4ab562a99d6 100644 --- a/lib/datadog/core/telemetry/worker.rb +++ b/lib/datadog/core/telemetry/worker.rb @@ -135,7 +135,7 @@ def dequeue end def work_pending? - @run_loop || !buffer.empty? + run_loop? || !buffer.empty? end def buffer_klass From a2c9679c8a27db52f25e052369aef74e55d91591 Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Fri, 28 Jun 2024 17:20:55 +0200 Subject: [PATCH 33/49] Update message with shorten url --- ddtrace.gemspec | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/ddtrace.gemspec b/ddtrace.gemspec index 7d0b782dbcf..a549a0186b8 100644 --- a/ddtrace.gemspec +++ b/ddtrace.gemspec @@ -77,13 +77,12 @@ Gem::Specification.new do |spec| spec.extensions = ['ext/datadog_profiling_native_extension/extconf.rb', 'ext/datadog_profiling_loader/extconf.rb'] spec.post_install_message = <<-MSG - Thank you for installing ddtrace. + Thank you for installing ddtrace. We have released our next major version! - As of version 2, the `ddtrace` gem has been renamed to `datadog` to better represent the full suite of Datadog products. + As of version 2, `ddtrace` gem has been renamed to `datadog`. The 1.x series will now only receive maintenance updates for security and critical bug fixes. - To upgrade, please update your Gemfile to replace `ddtrace` with `datadog`. - - For detailed instructions on migration, see: https://github.com/DataDog/dd-trace-rb/blob/master/docs/UpgradeGuide2.md + To upgrade, please replace gem `ddtrace` with gem `datadog`. + For detailed instructions on migration, see: https://dtdg.co/ruby-v2-upgrade MSG end From 2abf12ef9f2eb566e9f60353bd9872a048138659 Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Mon, 1 Jul 2024 10:23:53 +0200 Subject: [PATCH 34/49] Add 1.23.3 to CHANGELOG.md --- CHANGELOG.md | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 76192e0c435..21cc898ec5c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,17 @@ ## [Unreleased] +## [1.23.3] - 2024-07-01 + +### Added + +* Add post install message about 2.x upgrade ([#3723][]) + +### Fixed + +* Fix telemetry events blocking main thread ([#3740][]) +* Fix deadlock from telemetry threads ([#3745][]) + ## [1.23.2] - 2024-06-13 ### Fixed @@ -2826,7 +2837,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.23.2...1.x-stable +[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.3...1.x-stable +[1.23.3]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.2...v1.23.3 [1.23.2]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.1...v1.23.2 [1.23.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.0...v1.23.1 [1.23.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.22.0...v1.23.0 @@ -4142,6 +4154,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1 [#3623]: https://github.com/DataDog/dd-trace-rb/issues/3623 [#3650]: https://github.com/DataDog/dd-trace-rb/issues/3650 [#3683]: https://github.com/DataDog/dd-trace-rb/issues/3683 +[#3745]: https://github.com/DataDog/dd-trace-rb/issues/3745 [@AdrianLC]: https://github.com/AdrianLC [@Azure7111]: https://github.com/Azure7111 [@BabyGroot]: https://github.com/BabyGroot From 02c99b571a920c1ade10d371df5f10ceffd0a342 Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Mon, 1 Jul 2024 10:24:15 +0200 Subject: [PATCH 35/49] Bump version 1.23.2 to 1.23.3 --- lib/ddtrace/version.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/ddtrace/version.rb b/lib/ddtrace/version.rb index 7901fb6c3ab..1b64a14d669 100644 --- a/lib/ddtrace/version.rb +++ b/lib/ddtrace/version.rb @@ -4,7 +4,7 @@ module DDTrace module VERSION MAJOR = 1 MINOR = 23 - PATCH = 2 + PATCH = 3 PRE = nil BUILD = nil # PRE and BUILD above are modified for dev gems during gem build GHA workflow From 5ec8959ba634cb74ebb820227218678fe77b082d Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Mon, 1 Jul 2024 10:24:26 +0200 Subject: [PATCH 36/49] Update lockfiles for release 1.23.3 --- gemfiles/jruby_9.2.21.0_sinatra.gemfile.lock | 2 +- gemfiles/jruby_9.2_activesupport.gemfile.lock | 2 +- gemfiles/jruby_9.2_aws.gemfile.lock | 2 +- gemfiles/jruby_9.2_contrib.gemfile.lock | 2 +- gemfiles/jruby_9.2_contrib_old.gemfile.lock | 2 +- gemfiles/jruby_9.2_core_old.gemfile.lock | 2 +- gemfiles/jruby_9.2_elasticsearch_7.gemfile.lock | 2 +- gemfiles/jruby_9.2_elasticsearch_8.gemfile.lock | 2 +- gemfiles/jruby_9.2_graphql_1.12.gemfile.lock | 2 +- gemfiles/jruby_9.2_graphql_1.13.gemfile.lock | 2 +- gemfiles/jruby_9.2_graphql_2.0.gemfile.lock | 2 +- gemfiles/jruby_9.2_hanami_1.gemfile.lock | 2 +- gemfiles/jruby_9.2_http.gemfile.lock | 2 +- gemfiles/jruby_9.2_multi_rack_app.gemfile.lock | 2 +- gemfiles/jruby_9.2_opensearch_2.gemfile.lock | 2 +- gemfiles/jruby_9.2_opensearch_3.gemfile.lock | 2 +- gemfiles/jruby_9.2_opentracing.gemfile.lock | 2 +- gemfiles/jruby_9.2_rack_1.gemfile.lock | 2 +- gemfiles/jruby_9.2_rack_2.gemfile.lock | 2 +- gemfiles/jruby_9.2_rack_3.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails5_mysql2.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails5_postgres.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails5_postgres_redis.gemfile.lock | 2 +- .../jruby_9.2_rails5_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails5_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails5_semantic_logger.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails61_mysql2.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails61_postgres.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails6_mysql2.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails6_postgres.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails6_postgres_redis.gemfile.lock | 2 +- .../jruby_9.2_rails6_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails6_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/jruby_9.2_rails6_semantic_logger.gemfile.lock | 2 +- gemfiles/jruby_9.2_redis_3.gemfile.lock | 2 +- gemfiles/jruby_9.2_redis_4.gemfile.lock | 2 +- gemfiles/jruby_9.2_redis_5.gemfile.lock | 2 +- gemfiles/jruby_9.2_relational_db.gemfile.lock | 2 +- gemfiles/jruby_9.2_resque2_redis3.gemfile.lock | 2 +- gemfiles/jruby_9.2_resque2_redis4.gemfile.lock | 2 +- gemfiles/jruby_9.2_sinatra.gemfile.lock | 2 +- gemfiles/jruby_9.3_activesupport.gemfile.lock | 2 +- gemfiles/jruby_9.3_aws.gemfile.lock | 2 +- gemfiles/jruby_9.3_contrib.gemfile.lock | 2 +- gemfiles/jruby_9.3_contrib_old.gemfile.lock | 2 +- gemfiles/jruby_9.3_core_old.gemfile.lock | 2 +- gemfiles/jruby_9.3_elasticsearch_7.gemfile.lock | 2 +- gemfiles/jruby_9.3_elasticsearch_8.gemfile.lock | 2 +- gemfiles/jruby_9.3_graphql_1.12.gemfile.lock | 2 +- gemfiles/jruby_9.3_graphql_1.13.gemfile.lock | 2 +- gemfiles/jruby_9.3_graphql_2.0.gemfile.lock | 2 +- gemfiles/jruby_9.3_hanami_1.gemfile.lock | 2 +- gemfiles/jruby_9.3_http.gemfile.lock | 2 +- gemfiles/jruby_9.3_multi_rack_app.gemfile.lock | 2 +- gemfiles/jruby_9.3_opensearch_2.gemfile.lock | 2 +- gemfiles/jruby_9.3_opensearch_3.gemfile.lock | 2 +- gemfiles/jruby_9.3_opentracing.gemfile.lock | 2 +- gemfiles/jruby_9.3_rack_1.gemfile.lock | 2 +- gemfiles/jruby_9.3_rack_2.gemfile.lock | 2 +- gemfiles/jruby_9.3_rack_3.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails5_mysql2.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails5_postgres.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails5_postgres_redis.gemfile.lock | 2 +- .../jruby_9.3_rails5_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails5_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails5_semantic_logger.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails61_mysql2.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails61_postgres.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails6_mysql2.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails6_postgres.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails6_postgres_redis.gemfile.lock | 2 +- .../jruby_9.3_rails6_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails6_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/jruby_9.3_rails6_semantic_logger.gemfile.lock | 2 +- gemfiles/jruby_9.3_redis_3.gemfile.lock | 2 +- gemfiles/jruby_9.3_redis_4.gemfile.lock | 2 +- gemfiles/jruby_9.3_redis_5.gemfile.lock | 2 +- gemfiles/jruby_9.3_relational_db.gemfile.lock | 2 +- gemfiles/jruby_9.3_resque2_redis3.gemfile.lock | 2 +- gemfiles/jruby_9.3_resque2_redis4.gemfile.lock | 2 +- gemfiles/jruby_9.3_sinatra.gemfile.lock | 2 +- gemfiles/jruby_9.4_activesupport.gemfile.lock | 2 +- gemfiles/jruby_9.4_aws.gemfile.lock | 2 +- gemfiles/jruby_9.4_contrib.gemfile.lock | 2 +- gemfiles/jruby_9.4_contrib_old.gemfile.lock | 2 +- gemfiles/jruby_9.4_core_old.gemfile.lock | 2 +- gemfiles/jruby_9.4_elasticsearch_7.gemfile.lock | 2 +- gemfiles/jruby_9.4_elasticsearch_8.gemfile.lock | 2 +- gemfiles/jruby_9.4_graphql_1.12.gemfile.lock | 2 +- gemfiles/jruby_9.4_graphql_1.13.gemfile.lock | 2 +- gemfiles/jruby_9.4_graphql_2.0.gemfile.lock | 2 +- gemfiles/jruby_9.4_graphql_2.1.gemfile.lock | 2 +- gemfiles/jruby_9.4_graphql_2.2.gemfile.lock | 2 +- gemfiles/jruby_9.4_http.gemfile.lock | 2 +- gemfiles/jruby_9.4_multi_rack_app.gemfile.lock | 2 +- gemfiles/jruby_9.4_opensearch_2.gemfile.lock | 2 +- gemfiles/jruby_9.4_opensearch_3.gemfile.lock | 2 +- gemfiles/jruby_9.4_opentracing.gemfile.lock | 2 +- gemfiles/jruby_9.4_rack_1.gemfile.lock | 2 +- gemfiles/jruby_9.4_rack_2.gemfile.lock | 2 +- gemfiles/jruby_9.4_rack_3.gemfile.lock | 2 +- gemfiles/jruby_9.4_rails61_mysql2.gemfile.lock | 2 +- gemfiles/jruby_9.4_rails61_postgres.gemfile.lock | 2 +- gemfiles/jruby_9.4_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/jruby_9.4_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/jruby_9.4_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/jruby_9.4_redis_3.gemfile.lock | 2 +- gemfiles/jruby_9.4_redis_4.gemfile.lock | 2 +- gemfiles/jruby_9.4_redis_5.gemfile.lock | 2 +- gemfiles/jruby_9.4_relational_db.gemfile.lock | 2 +- gemfiles/jruby_9.4_resque2_redis3.gemfile.lock | 2 +- gemfiles/jruby_9.4_resque2_redis4.gemfile.lock | 2 +- gemfiles/jruby_9.4_sinatra.gemfile.lock | 2 +- gemfiles/ruby_2.1_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.1_aws.gemfile.lock | 2 +- gemfiles/ruby_2.1_contrib.gemfile.lock | 2 +- gemfiles/ruby_2.1_core_old.gemfile.lock | 2 +- gemfiles/ruby_2.1_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_2.1_http.gemfile.lock | 2 +- gemfiles/ruby_2.1_opentracing.gemfile.lock | 2 +- gemfiles/ruby_2.1_rack_1.gemfile.lock | 2 +- gemfiles/ruby_2.1_rails32_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.1_rails32_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.1_rails32_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_2.1_rails32_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.1_rails4_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.1_rails4_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.1_rails4_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_2.1_rails4_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.1_redis_3.gemfile.lock | 2 +- gemfiles/ruby_2.1_relational_db.gemfile.lock | 2 +- gemfiles/ruby_2.1_sinatra.gemfile.lock | 2 +- gemfiles/ruby_2.2_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.2_aws.gemfile.lock | 2 +- gemfiles/ruby_2.2_contrib.gemfile.lock | 2 +- gemfiles/ruby_2.2_core_old.gemfile.lock | 2 +- gemfiles/ruby_2.2_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_2.2_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_2.2_http.gemfile.lock | 2 +- gemfiles/ruby_2.2_opentracing.gemfile.lock | 2 +- gemfiles/ruby_2.2_rack_1.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails32_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails32_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails32_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails32_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails4_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails4_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails4_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails4_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails4_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails5_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails5_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails5_postgres_redis.gemfile.lock | 2 +- .../ruby_2.2_rails5_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails5_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.2_rails5_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.2_redis_3.gemfile.lock | 2 +- gemfiles/ruby_2.2_relational_db.gemfile.lock | 2 +- gemfiles/ruby_2.2_sinatra.gemfile.lock | 2 +- gemfiles/ruby_2.3_activerecord_3.gemfile.lock | 2 +- gemfiles/ruby_2.3_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.3_aws.gemfile.lock | 2 +- gemfiles/ruby_2.3_contrib.gemfile.lock | 2 +- gemfiles/ruby_2.3_contrib_old.gemfile.lock | 2 +- gemfiles/ruby_2.3_core_old.gemfile.lock | 2 +- gemfiles/ruby_2.3_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_2.3_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_2.3_hanami_1.gemfile.lock | 2 +- gemfiles/ruby_2.3_http.gemfile.lock | 2 +- gemfiles/ruby_2.3_opentracing.gemfile.lock | 2 +- gemfiles/ruby_2.3_rack_1.gemfile.lock | 2 +- gemfiles/ruby_2.3_rack_2.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails32_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails32_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails32_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails32_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails4_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails4_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails4_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails4_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails4_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails5_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails5_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails5_postgres_redis.gemfile.lock | 2 +- .../ruby_2.3_rails5_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails5_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.3_rails5_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.3_redis_3.gemfile.lock | 2 +- gemfiles/ruby_2.3_relational_db.gemfile.lock | 2 +- gemfiles/ruby_2.3_resque2_redis3.gemfile.lock | 2 +- gemfiles/ruby_2.3_resque2_redis4.gemfile.lock | 2 +- gemfiles/ruby_2.3_sinatra.gemfile.lock | 2 +- gemfiles/ruby_2.4_activerecord_4.gemfile.lock | 2 +- gemfiles/ruby_2.4_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.4_aws.gemfile.lock | 2 +- gemfiles/ruby_2.4_contrib.gemfile.lock | 2 +- gemfiles/ruby_2.4_contrib_old.gemfile.lock | 2 +- gemfiles/ruby_2.4_core_old.gemfile.lock | 2 +- gemfiles/ruby_2.4_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_2.4_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_2.4_graphql_1.13.gemfile.lock | 2 +- gemfiles/ruby_2.4_graphql_2.0.gemfile.lock | 2 +- gemfiles/ruby_2.4_hanami_1.gemfile.lock | 2 +- gemfiles/ruby_2.4_http.gemfile.lock | 2 +- gemfiles/ruby_2.4_opensearch_2.gemfile.lock | 2 +- gemfiles/ruby_2.4_opentracing.gemfile.lock | 2 +- gemfiles/ruby_2.4_rack_1.gemfile.lock | 2 +- gemfiles/ruby_2.4_rack_2.gemfile.lock | 2 +- gemfiles/ruby_2.4_rack_3.gemfile.lock | 2 +- gemfiles/ruby_2.4_rails5_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.4_rails5_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.4_rails5_postgres_redis.gemfile.lock | 2 +- .../ruby_2.4_rails5_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.4_rails5_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.4_rails5_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.4_redis_3.gemfile.lock | 2 +- gemfiles/ruby_2.4_redis_4.gemfile.lock | 2 +- gemfiles/ruby_2.4_relational_db.gemfile.lock | 2 +- gemfiles/ruby_2.4_resque2_redis3.gemfile.lock | 2 +- gemfiles/ruby_2.4_resque2_redis4.gemfile.lock | 2 +- gemfiles/ruby_2.4_sinatra.gemfile.lock | 2 +- gemfiles/ruby_2.5_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.5_aws.gemfile.lock | 2 +- gemfiles/ruby_2.5_contrib.gemfile.lock | 2 +- gemfiles/ruby_2.5_contrib_old.gemfile.lock | 2 +- gemfiles/ruby_2.5_core_old.gemfile.lock | 2 +- gemfiles/ruby_2.5_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_2.5_elasticsearch_8.gemfile.lock | 2 +- gemfiles/ruby_2.5_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_2.5_graphql_1.13.gemfile.lock | 2 +- gemfiles/ruby_2.5_graphql_2.0.gemfile.lock | 2 +- gemfiles/ruby_2.5_hanami_1.gemfile.lock | 2 +- gemfiles/ruby_2.5_http.gemfile.lock | 2 +- gemfiles/ruby_2.5_multi_rack_app.gemfile.lock | 2 +- gemfiles/ruby_2.5_opensearch_2.gemfile.lock | 2 +- gemfiles/ruby_2.5_opensearch_3.gemfile.lock | 2 +- gemfiles/ruby_2.5_opentracing.gemfile.lock | 2 +- gemfiles/ruby_2.5_rack_1.gemfile.lock | 2 +- gemfiles/ruby_2.5_rack_2.gemfile.lock | 2 +- gemfiles/ruby_2.5_rack_3.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails5_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails5_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails5_postgres_redis.gemfile.lock | 2 +- .../ruby_2.5_rails5_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails5_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails5_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails61_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails61_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails6_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails6_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails6_postgres_redis.gemfile.lock | 2 +- .../ruby_2.5_rails6_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails6_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.5_rails6_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.5_redis_3.gemfile.lock | 2 +- gemfiles/ruby_2.5_redis_4.gemfile.lock | 2 +- gemfiles/ruby_2.5_redis_5.gemfile.lock | 2 +- gemfiles/ruby_2.5_relational_db.gemfile.lock | 2 +- gemfiles/ruby_2.5_resque2_redis3.gemfile.lock | 2 +- gemfiles/ruby_2.5_resque2_redis4.gemfile.lock | 2 +- gemfiles/ruby_2.5_sinatra.gemfile.lock | 2 +- gemfiles/ruby_2.6_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.6_aws.gemfile.lock | 2 +- gemfiles/ruby_2.6_contrib.gemfile.lock | 2 +- gemfiles/ruby_2.6_contrib_old.gemfile.lock | 2 +- gemfiles/ruby_2.6_core_old.gemfile.lock | 2 +- gemfiles/ruby_2.6_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_2.6_elasticsearch_8.gemfile.lock | 2 +- gemfiles/ruby_2.6_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_2.6_graphql_1.13.gemfile.lock | 2 +- gemfiles/ruby_2.6_graphql_2.0.gemfile.lock | 2 +- gemfiles/ruby_2.6_hanami_1.gemfile.lock | 2 +- gemfiles/ruby_2.6_http.gemfile.lock | 2 +- gemfiles/ruby_2.6_multi_rack_app.gemfile.lock | 2 +- gemfiles/ruby_2.6_opensearch_2.gemfile.lock | 2 +- gemfiles/ruby_2.6_opensearch_3.gemfile.lock | 2 +- gemfiles/ruby_2.6_opentelemetry.gemfile.lock | 2 +- gemfiles/ruby_2.6_opentracing.gemfile.lock | 2 +- gemfiles/ruby_2.6_rack_1.gemfile.lock | 2 +- gemfiles/ruby_2.6_rack_2.gemfile.lock | 2 +- gemfiles/ruby_2.6_rack_3.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails5_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails5_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails5_postgres_redis.gemfile.lock | 2 +- .../ruby_2.6_rails5_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails5_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails5_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails61_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails61_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails6_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails6_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails6_postgres_redis.gemfile.lock | 2 +- .../ruby_2.6_rails6_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails6_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.6_rails6_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.6_redis_3.gemfile.lock | 2 +- gemfiles/ruby_2.6_redis_4.gemfile.lock | 2 +- gemfiles/ruby_2.6_redis_5.gemfile.lock | 2 +- gemfiles/ruby_2.6_relational_db.gemfile.lock | 2 +- gemfiles/ruby_2.6_resque2_redis3.gemfile.lock | 2 +- gemfiles/ruby_2.6_resque2_redis4.gemfile.lock | 2 +- gemfiles/ruby_2.6_sinatra.gemfile.lock | 2 +- gemfiles/ruby_2.7.6_sinatra.gemfile.lock | 2 +- gemfiles/ruby_2.7_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.7_aws.gemfile.lock | 2 +- gemfiles/ruby_2.7_contrib.gemfile.lock | 2 +- gemfiles/ruby_2.7_contrib_old.gemfile.lock | 2 +- gemfiles/ruby_2.7_core_old.gemfile.lock | 2 +- gemfiles/ruby_2.7_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_2.7_elasticsearch_8.gemfile.lock | 2 +- gemfiles/ruby_2.7_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_2.7_graphql_1.13.gemfile.lock | 2 +- gemfiles/ruby_2.7_graphql_2.0.gemfile.lock | 2 +- gemfiles/ruby_2.7_graphql_2.1.gemfile.lock | 2 +- gemfiles/ruby_2.7_graphql_2.2.gemfile.lock | 2 +- gemfiles/ruby_2.7_hanami_1.gemfile.lock | 2 +- gemfiles/ruby_2.7_http.gemfile.lock | 2 +- gemfiles/ruby_2.7_multi_rack_app.gemfile.lock | 2 +- gemfiles/ruby_2.7_opensearch_2.gemfile.lock | 2 +- gemfiles/ruby_2.7_opensearch_3.gemfile.lock | 2 +- gemfiles/ruby_2.7_opentelemetry.gemfile.lock | 2 +- gemfiles/ruby_2.7_opentracing.gemfile.lock | 2 +- gemfiles/ruby_2.7_rack_1.gemfile.lock | 2 +- gemfiles/ruby_2.7_rack_2.gemfile.lock | 2 +- gemfiles/ruby_2.7_rack_3.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails5_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails5_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails5_postgres_redis.gemfile.lock | 2 +- .../ruby_2.7_rails5_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails5_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails5_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails61_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails61_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails6_mysql2.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails6_postgres.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails6_postgres_redis.gemfile.lock | 2 +- .../ruby_2.7_rails6_postgres_redis_activesupport.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails6_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_2.7_rails6_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_2.7_redis_3.gemfile.lock | 2 +- gemfiles/ruby_2.7_redis_4.gemfile.lock | 2 +- gemfiles/ruby_2.7_redis_5.gemfile.lock | 2 +- gemfiles/ruby_2.7_relational_db.gemfile.lock | 2 +- gemfiles/ruby_2.7_resque2_redis3.gemfile.lock | 2 +- gemfiles/ruby_2.7_resque2_redis4.gemfile.lock | 2 +- gemfiles/ruby_2.7_sinatra.gemfile.lock | 2 +- gemfiles/ruby_3.0_activesupport.gemfile.lock | 2 +- gemfiles/ruby_3.0_aws.gemfile.lock | 2 +- gemfiles/ruby_3.0_contrib.gemfile.lock | 2 +- gemfiles/ruby_3.0_contrib_old.gemfile.lock | 2 +- gemfiles/ruby_3.0_core_old.gemfile.lock | 2 +- gemfiles/ruby_3.0_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_3.0_elasticsearch_8.gemfile.lock | 2 +- gemfiles/ruby_3.0_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_3.0_graphql_1.13.gemfile.lock | 2 +- gemfiles/ruby_3.0_graphql_2.0.gemfile.lock | 2 +- gemfiles/ruby_3.0_graphql_2.1.gemfile.lock | 2 +- gemfiles/ruby_3.0_graphql_2.2.gemfile.lock | 2 +- gemfiles/ruby_3.0_http.gemfile.lock | 2 +- gemfiles/ruby_3.0_multi_rack_app.gemfile.lock | 2 +- gemfiles/ruby_3.0_opensearch_2.gemfile.lock | 2 +- gemfiles/ruby_3.0_opensearch_3.gemfile.lock | 2 +- gemfiles/ruby_3.0_opentelemetry.gemfile.lock | 2 +- gemfiles/ruby_3.0_opentracing.gemfile.lock | 2 +- gemfiles/ruby_3.0_rack_1.gemfile.lock | 2 +- gemfiles/ruby_3.0_rack_2.gemfile.lock | 2 +- gemfiles/ruby_3.0_rack_3.gemfile.lock | 2 +- gemfiles/ruby_3.0_rails61_mysql2.gemfile.lock | 2 +- gemfiles/ruby_3.0_rails61_postgres.gemfile.lock | 2 +- gemfiles/ruby_3.0_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_3.0_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_3.0_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_3.0_rails61_trilogy.gemfile.lock | 2 +- gemfiles/ruby_3.0_redis_3.gemfile.lock | 2 +- gemfiles/ruby_3.0_redis_4.gemfile.lock | 2 +- gemfiles/ruby_3.0_redis_5.gemfile.lock | 2 +- gemfiles/ruby_3.0_relational_db.gemfile.lock | 2 +- gemfiles/ruby_3.0_resque2_redis3.gemfile.lock | 2 +- gemfiles/ruby_3.0_resque2_redis4.gemfile.lock | 2 +- gemfiles/ruby_3.0_sinatra.gemfile.lock | 2 +- gemfiles/ruby_3.1_activesupport.gemfile.lock | 2 +- gemfiles/ruby_3.1_aws.gemfile.lock | 2 +- gemfiles/ruby_3.1_contrib.gemfile.lock | 2 +- gemfiles/ruby_3.1_contrib_old.gemfile.lock | 2 +- gemfiles/ruby_3.1_core_old.gemfile.lock | 2 +- gemfiles/ruby_3.1_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_3.1_elasticsearch_8.gemfile.lock | 2 +- gemfiles/ruby_3.1_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_3.1_graphql_1.13.gemfile.lock | 2 +- gemfiles/ruby_3.1_graphql_2.0.gemfile.lock | 2 +- gemfiles/ruby_3.1_graphql_2.1.gemfile.lock | 2 +- gemfiles/ruby_3.1_graphql_2.2.gemfile.lock | 2 +- gemfiles/ruby_3.1_http.gemfile.lock | 2 +- gemfiles/ruby_3.1_opensearch_2.gemfile.lock | 2 +- gemfiles/ruby_3.1_opensearch_3.gemfile.lock | 2 +- gemfiles/ruby_3.1_opentelemetry.gemfile.lock | 2 +- gemfiles/ruby_3.1_opentracing.gemfile.lock | 2 +- gemfiles/ruby_3.1_rack_1.gemfile.lock | 2 +- gemfiles/ruby_3.1_rack_2.gemfile.lock | 2 +- gemfiles/ruby_3.1_rack_3.gemfile.lock | 2 +- gemfiles/ruby_3.1_rails61_mysql2.gemfile.lock | 2 +- gemfiles/ruby_3.1_rails61_postgres.gemfile.lock | 2 +- gemfiles/ruby_3.1_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_3.1_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_3.1_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_3.1_rails61_trilogy.gemfile.lock | 2 +- gemfiles/ruby_3.1_redis_3.gemfile.lock | 2 +- gemfiles/ruby_3.1_redis_4.gemfile.lock | 2 +- gemfiles/ruby_3.1_redis_5.gemfile.lock | 2 +- gemfiles/ruby_3.1_relational_db.gemfile.lock | 2 +- gemfiles/ruby_3.1_resque2_redis3.gemfile.lock | 2 +- gemfiles/ruby_3.1_resque2_redis4.gemfile.lock | 2 +- gemfiles/ruby_3.1_sinatra.gemfile.lock | 2 +- gemfiles/ruby_3.2_activesupport.gemfile.lock | 2 +- gemfiles/ruby_3.2_aws.gemfile.lock | 2 +- gemfiles/ruby_3.2_contrib.gemfile.lock | 2 +- gemfiles/ruby_3.2_contrib_old.gemfile.lock | 2 +- gemfiles/ruby_3.2_core_old.gemfile.lock | 2 +- gemfiles/ruby_3.2_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_3.2_elasticsearch_8.gemfile.lock | 2 +- gemfiles/ruby_3.2_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_3.2_graphql_1.13.gemfile.lock | 2 +- gemfiles/ruby_3.2_graphql_2.0.gemfile.lock | 2 +- gemfiles/ruby_3.2_graphql_2.1.gemfile.lock | 2 +- gemfiles/ruby_3.2_graphql_2.2.gemfile.lock | 2 +- gemfiles/ruby_3.2_http.gemfile.lock | 2 +- gemfiles/ruby_3.2_multi_rack_app.gemfile.lock | 2 +- gemfiles/ruby_3.2_opensearch_2.gemfile.lock | 2 +- gemfiles/ruby_3.2_opensearch_3.gemfile.lock | 2 +- gemfiles/ruby_3.2_opentelemetry.gemfile.lock | 2 +- gemfiles/ruby_3.2_opentracing.gemfile.lock | 2 +- gemfiles/ruby_3.2_rack_1.gemfile.lock | 2 +- gemfiles/ruby_3.2_rack_2.gemfile.lock | 2 +- gemfiles/ruby_3.2_rack_3.gemfile.lock | 2 +- gemfiles/ruby_3.2_rails61_mysql2.gemfile.lock | 2 +- gemfiles/ruby_3.2_rails61_postgres.gemfile.lock | 2 +- gemfiles/ruby_3.2_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_3.2_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_3.2_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_3.2_rails61_trilogy.gemfile.lock | 2 +- gemfiles/ruby_3.2_redis_3.gemfile.lock | 2 +- gemfiles/ruby_3.2_redis_4.gemfile.lock | 2 +- gemfiles/ruby_3.2_redis_5.gemfile.lock | 2 +- gemfiles/ruby_3.2_relational_db.gemfile.lock | 2 +- gemfiles/ruby_3.2_resque2_redis3.gemfile.lock | 2 +- gemfiles/ruby_3.2_resque2_redis4.gemfile.lock | 2 +- gemfiles/ruby_3.2_sinatra.gemfile.lock | 2 +- gemfiles/ruby_3.3_activesupport.gemfile.lock | 2 +- gemfiles/ruby_3.3_aws.gemfile.lock | 2 +- gemfiles/ruby_3.3_contrib.gemfile.lock | 2 +- gemfiles/ruby_3.3_contrib_old.gemfile.lock | 2 +- gemfiles/ruby_3.3_core_old.gemfile.lock | 2 +- gemfiles/ruby_3.3_elasticsearch_7.gemfile.lock | 2 +- gemfiles/ruby_3.3_elasticsearch_8.gemfile.lock | 2 +- gemfiles/ruby_3.3_graphql_1.12.gemfile.lock | 2 +- gemfiles/ruby_3.3_graphql_1.13.gemfile.lock | 2 +- gemfiles/ruby_3.3_graphql_2.0.gemfile.lock | 2 +- gemfiles/ruby_3.3_graphql_2.1.gemfile.lock | 2 +- gemfiles/ruby_3.3_graphql_2.2.gemfile.lock | 2 +- gemfiles/ruby_3.3_http.gemfile.lock | 2 +- gemfiles/ruby_3.3_multi_rack_app.gemfile.lock | 2 +- gemfiles/ruby_3.3_opensearch_2.gemfile.lock | 2 +- gemfiles/ruby_3.3_opensearch_3.gemfile.lock | 2 +- gemfiles/ruby_3.3_opentelemetry.gemfile.lock | 2 +- gemfiles/ruby_3.3_opentracing.gemfile.lock | 2 +- gemfiles/ruby_3.3_rack_1.gemfile.lock | 2 +- gemfiles/ruby_3.3_rack_2.gemfile.lock | 2 +- gemfiles/ruby_3.3_rack_3.gemfile.lock | 2 +- gemfiles/ruby_3.3_rails61_mysql2.gemfile.lock | 2 +- gemfiles/ruby_3.3_rails61_postgres.gemfile.lock | 2 +- gemfiles/ruby_3.3_rails61_postgres_redis.gemfile.lock | 2 +- gemfiles/ruby_3.3_rails61_postgres_sidekiq.gemfile.lock | 2 +- gemfiles/ruby_3.3_rails61_semantic_logger.gemfile.lock | 2 +- gemfiles/ruby_3.3_rails61_trilogy.gemfile.lock | 2 +- gemfiles/ruby_3.3_redis_3.gemfile.lock | 2 +- gemfiles/ruby_3.3_redis_4.gemfile.lock | 2 +- gemfiles/ruby_3.3_redis_5.gemfile.lock | 2 +- gemfiles/ruby_3.3_relational_db.gemfile.lock | 2 +- gemfiles/ruby_3.3_resque2_redis3.gemfile.lock | 2 +- gemfiles/ruby_3.3_resque2_redis4.gemfile.lock | 2 +- gemfiles/ruby_3.3_sinatra.gemfile.lock | 2 +- 496 files changed, 496 insertions(+), 496 deletions(-) diff --git a/gemfiles/jruby_9.2.21.0_sinatra.gemfile.lock b/gemfiles/jruby_9.2.21.0_sinatra.gemfile.lock index 0ef26bab4da..ead81b7254c 100644 --- a/gemfiles/jruby_9.2.21.0_sinatra.gemfile.lock +++ b/gemfiles/jruby_9.2.21.0_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.2.0) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_activesupport.gemfile.lock b/gemfiles/jruby_9.2_activesupport.gemfile.lock index 31244c1a079..0e0d7de01c4 100644 --- a/gemfiles/jruby_9.2_activesupport.gemfile.lock +++ b/gemfiles/jruby_9.2_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_aws.gemfile.lock b/gemfiles/jruby_9.2_aws.gemfile.lock index b575867131c..e6b3ebfd9c0 100644 --- a/gemfiles/jruby_9.2_aws.gemfile.lock +++ b/gemfiles/jruby_9.2_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_contrib.gemfile.lock b/gemfiles/jruby_9.2_contrib.gemfile.lock index 020077c84e4..9bf64d41bb4 100644 --- a/gemfiles/jruby_9.2_contrib.gemfile.lock +++ b/gemfiles/jruby_9.2_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_contrib_old.gemfile.lock b/gemfiles/jruby_9.2_contrib_old.gemfile.lock index fed3fc1311a..280f3c3193c 100644 --- a/gemfiles/jruby_9.2_contrib_old.gemfile.lock +++ b/gemfiles/jruby_9.2_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_core_old.gemfile.lock b/gemfiles/jruby_9.2_core_old.gemfile.lock index ffe94825475..8c7a37409e6 100644 --- a/gemfiles/jruby_9.2_core_old.gemfile.lock +++ b/gemfiles/jruby_9.2_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_elasticsearch_7.gemfile.lock b/gemfiles/jruby_9.2_elasticsearch_7.gemfile.lock index 9b33908b45c..3d116c683bb 100644 --- a/gemfiles/jruby_9.2_elasticsearch_7.gemfile.lock +++ b/gemfiles/jruby_9.2_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_elasticsearch_8.gemfile.lock b/gemfiles/jruby_9.2_elasticsearch_8.gemfile.lock index f043a34f07b..cbfbd701d47 100644 --- a/gemfiles/jruby_9.2_elasticsearch_8.gemfile.lock +++ b/gemfiles/jruby_9.2_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_graphql_1.12.gemfile.lock b/gemfiles/jruby_9.2_graphql_1.12.gemfile.lock index 5a30259ec0c..6189ce37ed7 100644 --- a/gemfiles/jruby_9.2_graphql_1.12.gemfile.lock +++ b/gemfiles/jruby_9.2_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_graphql_1.13.gemfile.lock b/gemfiles/jruby_9.2_graphql_1.13.gemfile.lock index 9c9b2132b59..07aabc41fe8 100644 --- a/gemfiles/jruby_9.2_graphql_1.13.gemfile.lock +++ b/gemfiles/jruby_9.2_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_graphql_2.0.gemfile.lock b/gemfiles/jruby_9.2_graphql_2.0.gemfile.lock index d12a878b9ec..3640261a43d 100644 --- a/gemfiles/jruby_9.2_graphql_2.0.gemfile.lock +++ b/gemfiles/jruby_9.2_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_hanami_1.gemfile.lock b/gemfiles/jruby_9.2_hanami_1.gemfile.lock index 1d5416bd24f..c36d9012aa8 100644 --- a/gemfiles/jruby_9.2_hanami_1.gemfile.lock +++ b/gemfiles/jruby_9.2_hanami_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_http.gemfile.lock b/gemfiles/jruby_9.2_http.gemfile.lock index 96435aa5cfc..7c7d5aca822 100644 --- a/gemfiles/jruby_9.2_http.gemfile.lock +++ b/gemfiles/jruby_9.2_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_multi_rack_app.gemfile.lock b/gemfiles/jruby_9.2_multi_rack_app.gemfile.lock index edd76c4953f..a2e31498780 100644 --- a/gemfiles/jruby_9.2_multi_rack_app.gemfile.lock +++ b/gemfiles/jruby_9.2_multi_rack_app.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_opensearch_2.gemfile.lock b/gemfiles/jruby_9.2_opensearch_2.gemfile.lock index 08e59a46c63..e3de850540a 100644 --- a/gemfiles/jruby_9.2_opensearch_2.gemfile.lock +++ b/gemfiles/jruby_9.2_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_opensearch_3.gemfile.lock b/gemfiles/jruby_9.2_opensearch_3.gemfile.lock index eb19c909295..12e81835510 100644 --- a/gemfiles/jruby_9.2_opensearch_3.gemfile.lock +++ b/gemfiles/jruby_9.2_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_opentracing.gemfile.lock b/gemfiles/jruby_9.2_opentracing.gemfile.lock index 1371a3a24c9..def55341945 100644 --- a/gemfiles/jruby_9.2_opentracing.gemfile.lock +++ b/gemfiles/jruby_9.2_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rack_1.gemfile.lock b/gemfiles/jruby_9.2_rack_1.gemfile.lock index 1ed75d57fba..c45823150ee 100644 --- a/gemfiles/jruby_9.2_rack_1.gemfile.lock +++ b/gemfiles/jruby_9.2_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rack_2.gemfile.lock b/gemfiles/jruby_9.2_rack_2.gemfile.lock index 430728fc3d6..d435470d7b4 100644 --- a/gemfiles/jruby_9.2_rack_2.gemfile.lock +++ b/gemfiles/jruby_9.2_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rack_3.gemfile.lock b/gemfiles/jruby_9.2_rack_3.gemfile.lock index db48fcc91e7..6a86bc1f1a8 100644 --- a/gemfiles/jruby_9.2_rack_3.gemfile.lock +++ b/gemfiles/jruby_9.2_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails5_mysql2.gemfile.lock b/gemfiles/jruby_9.2_rails5_mysql2.gemfile.lock index 14f015f5609..3583a95a307 100644 --- a/gemfiles/jruby_9.2_rails5_mysql2.gemfile.lock +++ b/gemfiles/jruby_9.2_rails5_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails5_postgres.gemfile.lock b/gemfiles/jruby_9.2_rails5_postgres.gemfile.lock index fd3edbb4772..0de1d0c1645 100644 --- a/gemfiles/jruby_9.2_rails5_postgres.gemfile.lock +++ b/gemfiles/jruby_9.2_rails5_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails5_postgres_redis.gemfile.lock b/gemfiles/jruby_9.2_rails5_postgres_redis.gemfile.lock index 376bd56bfd0..45c9bd7ff4b 100644 --- a/gemfiles/jruby_9.2_rails5_postgres_redis.gemfile.lock +++ b/gemfiles/jruby_9.2_rails5_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails5_postgres_redis_activesupport.gemfile.lock b/gemfiles/jruby_9.2_rails5_postgres_redis_activesupport.gemfile.lock index 658e3126119..ea4d8337559 100644 --- a/gemfiles/jruby_9.2_rails5_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/jruby_9.2_rails5_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails5_postgres_sidekiq.gemfile.lock b/gemfiles/jruby_9.2_rails5_postgres_sidekiq.gemfile.lock index 03da844613c..fdffadc7ede 100644 --- a/gemfiles/jruby_9.2_rails5_postgres_sidekiq.gemfile.lock +++ b/gemfiles/jruby_9.2_rails5_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails5_semantic_logger.gemfile.lock b/gemfiles/jruby_9.2_rails5_semantic_logger.gemfile.lock index c00aedaa7ee..3855f3e82fb 100644 --- a/gemfiles/jruby_9.2_rails5_semantic_logger.gemfile.lock +++ b/gemfiles/jruby_9.2_rails5_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails61_mysql2.gemfile.lock b/gemfiles/jruby_9.2_rails61_mysql2.gemfile.lock index 19fb3515e99..ecf9e6940b8 100644 --- a/gemfiles/jruby_9.2_rails61_mysql2.gemfile.lock +++ b/gemfiles/jruby_9.2_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails61_postgres.gemfile.lock b/gemfiles/jruby_9.2_rails61_postgres.gemfile.lock index 00cc91c2fe3..8e51fd22549 100644 --- a/gemfiles/jruby_9.2_rails61_postgres.gemfile.lock +++ b/gemfiles/jruby_9.2_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails61_postgres_redis.gemfile.lock b/gemfiles/jruby_9.2_rails61_postgres_redis.gemfile.lock index 202f55a6d3a..2e8a8c6794d 100644 --- a/gemfiles/jruby_9.2_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/jruby_9.2_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/jruby_9.2_rails61_postgres_sidekiq.gemfile.lock index 0904db81eb5..a05af519d8c 100644 --- a/gemfiles/jruby_9.2_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/jruby_9.2_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails61_semantic_logger.gemfile.lock b/gemfiles/jruby_9.2_rails61_semantic_logger.gemfile.lock index 7cc4178b7a1..d87e89f1903 100644 --- a/gemfiles/jruby_9.2_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/jruby_9.2_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails6_mysql2.gemfile.lock b/gemfiles/jruby_9.2_rails6_mysql2.gemfile.lock index 8d2fc0f48bd..c56868e8a0b 100644 --- a/gemfiles/jruby_9.2_rails6_mysql2.gemfile.lock +++ b/gemfiles/jruby_9.2_rails6_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails6_postgres.gemfile.lock b/gemfiles/jruby_9.2_rails6_postgres.gemfile.lock index 2e0d86ad0a1..83e02d2e45e 100644 --- a/gemfiles/jruby_9.2_rails6_postgres.gemfile.lock +++ b/gemfiles/jruby_9.2_rails6_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails6_postgres_redis.gemfile.lock b/gemfiles/jruby_9.2_rails6_postgres_redis.gemfile.lock index 1f9641f06bc..6c82d1dcdb1 100644 --- a/gemfiles/jruby_9.2_rails6_postgres_redis.gemfile.lock +++ b/gemfiles/jruby_9.2_rails6_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails6_postgres_redis_activesupport.gemfile.lock b/gemfiles/jruby_9.2_rails6_postgres_redis_activesupport.gemfile.lock index 9b3eeebb842..1ab4096c790 100644 --- a/gemfiles/jruby_9.2_rails6_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/jruby_9.2_rails6_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails6_postgres_sidekiq.gemfile.lock b/gemfiles/jruby_9.2_rails6_postgres_sidekiq.gemfile.lock index db0a32a4668..804d8a64c5e 100644 --- a/gemfiles/jruby_9.2_rails6_postgres_sidekiq.gemfile.lock +++ b/gemfiles/jruby_9.2_rails6_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_rails6_semantic_logger.gemfile.lock b/gemfiles/jruby_9.2_rails6_semantic_logger.gemfile.lock index 6de401f09bf..8a9d97c46d0 100644 --- a/gemfiles/jruby_9.2_rails6_semantic_logger.gemfile.lock +++ b/gemfiles/jruby_9.2_rails6_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_redis_3.gemfile.lock b/gemfiles/jruby_9.2_redis_3.gemfile.lock index 24da82be8b5..8082bdcde27 100644 --- a/gemfiles/jruby_9.2_redis_3.gemfile.lock +++ b/gemfiles/jruby_9.2_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_redis_4.gemfile.lock b/gemfiles/jruby_9.2_redis_4.gemfile.lock index 7125bf469dc..5a0abed7763 100644 --- a/gemfiles/jruby_9.2_redis_4.gemfile.lock +++ b/gemfiles/jruby_9.2_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_redis_5.gemfile.lock b/gemfiles/jruby_9.2_redis_5.gemfile.lock index bfa78d8d777..901f33b1fde 100644 --- a/gemfiles/jruby_9.2_redis_5.gemfile.lock +++ b/gemfiles/jruby_9.2_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_relational_db.gemfile.lock b/gemfiles/jruby_9.2_relational_db.gemfile.lock index 1e9ab3f96eb..672dee20f43 100644 --- a/gemfiles/jruby_9.2_relational_db.gemfile.lock +++ b/gemfiles/jruby_9.2_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_resque2_redis3.gemfile.lock b/gemfiles/jruby_9.2_resque2_redis3.gemfile.lock index 989ff386381..2b5152ca85f 100644 --- a/gemfiles/jruby_9.2_resque2_redis3.gemfile.lock +++ b/gemfiles/jruby_9.2_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_resque2_redis4.gemfile.lock b/gemfiles/jruby_9.2_resque2_redis4.gemfile.lock index ea86f8b36e7..570def4437c 100644 --- a/gemfiles/jruby_9.2_resque2_redis4.gemfile.lock +++ b/gemfiles/jruby_9.2_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.2_sinatra.gemfile.lock b/gemfiles/jruby_9.2_sinatra.gemfile.lock index ff19d1e9e65..2a0c324487a 100644 --- a/gemfiles/jruby_9.2_sinatra.gemfile.lock +++ b/gemfiles/jruby_9.2_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_activesupport.gemfile.lock b/gemfiles/jruby_9.3_activesupport.gemfile.lock index d7cd1a2f385..c733e73052a 100644 --- a/gemfiles/jruby_9.3_activesupport.gemfile.lock +++ b/gemfiles/jruby_9.3_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_aws.gemfile.lock b/gemfiles/jruby_9.3_aws.gemfile.lock index 5419e5f709a..2c137342475 100644 --- a/gemfiles/jruby_9.3_aws.gemfile.lock +++ b/gemfiles/jruby_9.3_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_contrib.gemfile.lock b/gemfiles/jruby_9.3_contrib.gemfile.lock index 345578e0b74..f039c4ecafd 100644 --- a/gemfiles/jruby_9.3_contrib.gemfile.lock +++ b/gemfiles/jruby_9.3_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_contrib_old.gemfile.lock b/gemfiles/jruby_9.3_contrib_old.gemfile.lock index 51503cc1696..80a02073fe5 100644 --- a/gemfiles/jruby_9.3_contrib_old.gemfile.lock +++ b/gemfiles/jruby_9.3_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_core_old.gemfile.lock b/gemfiles/jruby_9.3_core_old.gemfile.lock index d1404102a93..596c2c79f5a 100644 --- a/gemfiles/jruby_9.3_core_old.gemfile.lock +++ b/gemfiles/jruby_9.3_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_elasticsearch_7.gemfile.lock b/gemfiles/jruby_9.3_elasticsearch_7.gemfile.lock index 2671da6f950..3ef90878708 100644 --- a/gemfiles/jruby_9.3_elasticsearch_7.gemfile.lock +++ b/gemfiles/jruby_9.3_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_elasticsearch_8.gemfile.lock b/gemfiles/jruby_9.3_elasticsearch_8.gemfile.lock index f5ec400ba1c..2f007d3e26e 100644 --- a/gemfiles/jruby_9.3_elasticsearch_8.gemfile.lock +++ b/gemfiles/jruby_9.3_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_graphql_1.12.gemfile.lock b/gemfiles/jruby_9.3_graphql_1.12.gemfile.lock index 9d32642fb3d..5fbd218485a 100644 --- a/gemfiles/jruby_9.3_graphql_1.12.gemfile.lock +++ b/gemfiles/jruby_9.3_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_graphql_1.13.gemfile.lock b/gemfiles/jruby_9.3_graphql_1.13.gemfile.lock index bc919facf78..83124b2db8f 100644 --- a/gemfiles/jruby_9.3_graphql_1.13.gemfile.lock +++ b/gemfiles/jruby_9.3_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_graphql_2.0.gemfile.lock b/gemfiles/jruby_9.3_graphql_2.0.gemfile.lock index 7cb60a2f114..661cdeed047 100644 --- a/gemfiles/jruby_9.3_graphql_2.0.gemfile.lock +++ b/gemfiles/jruby_9.3_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_hanami_1.gemfile.lock b/gemfiles/jruby_9.3_hanami_1.gemfile.lock index 8dd674a1077..1608e7219a5 100644 --- a/gemfiles/jruby_9.3_hanami_1.gemfile.lock +++ b/gemfiles/jruby_9.3_hanami_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_http.gemfile.lock b/gemfiles/jruby_9.3_http.gemfile.lock index d7997a557ff..6618b9f3948 100644 --- a/gemfiles/jruby_9.3_http.gemfile.lock +++ b/gemfiles/jruby_9.3_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_multi_rack_app.gemfile.lock b/gemfiles/jruby_9.3_multi_rack_app.gemfile.lock index ffa4abfa502..1ca3086ca65 100644 --- a/gemfiles/jruby_9.3_multi_rack_app.gemfile.lock +++ b/gemfiles/jruby_9.3_multi_rack_app.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_opensearch_2.gemfile.lock b/gemfiles/jruby_9.3_opensearch_2.gemfile.lock index 6535c723bd7..f42dbeb7be5 100644 --- a/gemfiles/jruby_9.3_opensearch_2.gemfile.lock +++ b/gemfiles/jruby_9.3_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_opensearch_3.gemfile.lock b/gemfiles/jruby_9.3_opensearch_3.gemfile.lock index 8ae2783be6a..c1383d496f2 100644 --- a/gemfiles/jruby_9.3_opensearch_3.gemfile.lock +++ b/gemfiles/jruby_9.3_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_opentracing.gemfile.lock b/gemfiles/jruby_9.3_opentracing.gemfile.lock index 30182a5a4f6..723204a07e2 100644 --- a/gemfiles/jruby_9.3_opentracing.gemfile.lock +++ b/gemfiles/jruby_9.3_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rack_1.gemfile.lock b/gemfiles/jruby_9.3_rack_1.gemfile.lock index 9ac3f1c5cf8..8b8681f555d 100644 --- a/gemfiles/jruby_9.3_rack_1.gemfile.lock +++ b/gemfiles/jruby_9.3_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rack_2.gemfile.lock b/gemfiles/jruby_9.3_rack_2.gemfile.lock index fb0ee4ef3b5..19ad8c7ad57 100644 --- a/gemfiles/jruby_9.3_rack_2.gemfile.lock +++ b/gemfiles/jruby_9.3_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rack_3.gemfile.lock b/gemfiles/jruby_9.3_rack_3.gemfile.lock index dd6e1526898..cfa77081a55 100644 --- a/gemfiles/jruby_9.3_rack_3.gemfile.lock +++ b/gemfiles/jruby_9.3_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails5_mysql2.gemfile.lock b/gemfiles/jruby_9.3_rails5_mysql2.gemfile.lock index 8fb67b91fd7..1b1af0b668d 100644 --- a/gemfiles/jruby_9.3_rails5_mysql2.gemfile.lock +++ b/gemfiles/jruby_9.3_rails5_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails5_postgres.gemfile.lock b/gemfiles/jruby_9.3_rails5_postgres.gemfile.lock index 83bd9c9a985..cda4bcf1506 100644 --- a/gemfiles/jruby_9.3_rails5_postgres.gemfile.lock +++ b/gemfiles/jruby_9.3_rails5_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails5_postgres_redis.gemfile.lock b/gemfiles/jruby_9.3_rails5_postgres_redis.gemfile.lock index 543f4154f17..7a48d13cd82 100644 --- a/gemfiles/jruby_9.3_rails5_postgres_redis.gemfile.lock +++ b/gemfiles/jruby_9.3_rails5_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails5_postgres_redis_activesupport.gemfile.lock b/gemfiles/jruby_9.3_rails5_postgres_redis_activesupport.gemfile.lock index 729e2249b1c..879a6f4f36e 100644 --- a/gemfiles/jruby_9.3_rails5_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/jruby_9.3_rails5_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails5_postgres_sidekiq.gemfile.lock b/gemfiles/jruby_9.3_rails5_postgres_sidekiq.gemfile.lock index 4670659c0c4..5a03d15af5c 100644 --- a/gemfiles/jruby_9.3_rails5_postgres_sidekiq.gemfile.lock +++ b/gemfiles/jruby_9.3_rails5_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails5_semantic_logger.gemfile.lock b/gemfiles/jruby_9.3_rails5_semantic_logger.gemfile.lock index 3d708cfad4b..3f57105b2a9 100644 --- a/gemfiles/jruby_9.3_rails5_semantic_logger.gemfile.lock +++ b/gemfiles/jruby_9.3_rails5_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails61_mysql2.gemfile.lock b/gemfiles/jruby_9.3_rails61_mysql2.gemfile.lock index f6055376bf1..07f83075627 100644 --- a/gemfiles/jruby_9.3_rails61_mysql2.gemfile.lock +++ b/gemfiles/jruby_9.3_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails61_postgres.gemfile.lock b/gemfiles/jruby_9.3_rails61_postgres.gemfile.lock index a6ee05aa098..65312e23eda 100644 --- a/gemfiles/jruby_9.3_rails61_postgres.gemfile.lock +++ b/gemfiles/jruby_9.3_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails61_postgres_redis.gemfile.lock b/gemfiles/jruby_9.3_rails61_postgres_redis.gemfile.lock index 9f0d1abe03e..58f59728f9f 100644 --- a/gemfiles/jruby_9.3_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/jruby_9.3_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/jruby_9.3_rails61_postgres_sidekiq.gemfile.lock index 9dbd6ab9743..445f8de13c0 100644 --- a/gemfiles/jruby_9.3_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/jruby_9.3_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails61_semantic_logger.gemfile.lock b/gemfiles/jruby_9.3_rails61_semantic_logger.gemfile.lock index 23da1d437e5..0e3c8fc95cc 100644 --- a/gemfiles/jruby_9.3_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/jruby_9.3_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails6_mysql2.gemfile.lock b/gemfiles/jruby_9.3_rails6_mysql2.gemfile.lock index 5fe46e303b8..9db0d6d6a52 100644 --- a/gemfiles/jruby_9.3_rails6_mysql2.gemfile.lock +++ b/gemfiles/jruby_9.3_rails6_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails6_postgres.gemfile.lock b/gemfiles/jruby_9.3_rails6_postgres.gemfile.lock index 59f246ac96d..562c4d79aeb 100644 --- a/gemfiles/jruby_9.3_rails6_postgres.gemfile.lock +++ b/gemfiles/jruby_9.3_rails6_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails6_postgres_redis.gemfile.lock b/gemfiles/jruby_9.3_rails6_postgres_redis.gemfile.lock index 5d4a5f2b8c6..8d69e427338 100644 --- a/gemfiles/jruby_9.3_rails6_postgres_redis.gemfile.lock +++ b/gemfiles/jruby_9.3_rails6_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails6_postgres_redis_activesupport.gemfile.lock b/gemfiles/jruby_9.3_rails6_postgres_redis_activesupport.gemfile.lock index 1b6ae67acb0..67c654d2b0c 100644 --- a/gemfiles/jruby_9.3_rails6_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/jruby_9.3_rails6_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails6_postgres_sidekiq.gemfile.lock b/gemfiles/jruby_9.3_rails6_postgres_sidekiq.gemfile.lock index e13f2cff8be..e20c9285bd4 100644 --- a/gemfiles/jruby_9.3_rails6_postgres_sidekiq.gemfile.lock +++ b/gemfiles/jruby_9.3_rails6_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_rails6_semantic_logger.gemfile.lock b/gemfiles/jruby_9.3_rails6_semantic_logger.gemfile.lock index cae6c63487f..8951bbcf433 100644 --- a/gemfiles/jruby_9.3_rails6_semantic_logger.gemfile.lock +++ b/gemfiles/jruby_9.3_rails6_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_redis_3.gemfile.lock b/gemfiles/jruby_9.3_redis_3.gemfile.lock index be685b71ef9..482c0f34986 100644 --- a/gemfiles/jruby_9.3_redis_3.gemfile.lock +++ b/gemfiles/jruby_9.3_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_redis_4.gemfile.lock b/gemfiles/jruby_9.3_redis_4.gemfile.lock index 35c2dbc3ba6..bf2ed4146dc 100644 --- a/gemfiles/jruby_9.3_redis_4.gemfile.lock +++ b/gemfiles/jruby_9.3_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_redis_5.gemfile.lock b/gemfiles/jruby_9.3_redis_5.gemfile.lock index 4b8912164e2..eec358085f0 100644 --- a/gemfiles/jruby_9.3_redis_5.gemfile.lock +++ b/gemfiles/jruby_9.3_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_relational_db.gemfile.lock b/gemfiles/jruby_9.3_relational_db.gemfile.lock index 76314719f0e..35878cabd6d 100644 --- a/gemfiles/jruby_9.3_relational_db.gemfile.lock +++ b/gemfiles/jruby_9.3_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_resque2_redis3.gemfile.lock b/gemfiles/jruby_9.3_resque2_redis3.gemfile.lock index bdafd52c388..acfeeb49325 100644 --- a/gemfiles/jruby_9.3_resque2_redis3.gemfile.lock +++ b/gemfiles/jruby_9.3_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_resque2_redis4.gemfile.lock b/gemfiles/jruby_9.3_resque2_redis4.gemfile.lock index 5927d10b2e3..563b0ede056 100644 --- a/gemfiles/jruby_9.3_resque2_redis4.gemfile.lock +++ b/gemfiles/jruby_9.3_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.3_sinatra.gemfile.lock b/gemfiles/jruby_9.3_sinatra.gemfile.lock index 2181f3938fb..4661b6c0e19 100644 --- a/gemfiles/jruby_9.3_sinatra.gemfile.lock +++ b/gemfiles/jruby_9.3_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_activesupport.gemfile.lock b/gemfiles/jruby_9.4_activesupport.gemfile.lock index a102172d7ba..8229c509b89 100644 --- a/gemfiles/jruby_9.4_activesupport.gemfile.lock +++ b/gemfiles/jruby_9.4_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_aws.gemfile.lock b/gemfiles/jruby_9.4_aws.gemfile.lock index 0b019a5b94a..432522934d5 100644 --- a/gemfiles/jruby_9.4_aws.gemfile.lock +++ b/gemfiles/jruby_9.4_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_contrib.gemfile.lock b/gemfiles/jruby_9.4_contrib.gemfile.lock index 08f49857afc..02ee98864a0 100644 --- a/gemfiles/jruby_9.4_contrib.gemfile.lock +++ b/gemfiles/jruby_9.4_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_contrib_old.gemfile.lock b/gemfiles/jruby_9.4_contrib_old.gemfile.lock index 4869839ce02..c7d4cda6da9 100644 --- a/gemfiles/jruby_9.4_contrib_old.gemfile.lock +++ b/gemfiles/jruby_9.4_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_core_old.gemfile.lock b/gemfiles/jruby_9.4_core_old.gemfile.lock index 5172c3e879d..db8c1bf7dc1 100644 --- a/gemfiles/jruby_9.4_core_old.gemfile.lock +++ b/gemfiles/jruby_9.4_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_elasticsearch_7.gemfile.lock b/gemfiles/jruby_9.4_elasticsearch_7.gemfile.lock index 6ae0b71a462..f1152b7f857 100644 --- a/gemfiles/jruby_9.4_elasticsearch_7.gemfile.lock +++ b/gemfiles/jruby_9.4_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_elasticsearch_8.gemfile.lock b/gemfiles/jruby_9.4_elasticsearch_8.gemfile.lock index 1ea7340f63a..ef282cb96f5 100644 --- a/gemfiles/jruby_9.4_elasticsearch_8.gemfile.lock +++ b/gemfiles/jruby_9.4_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_graphql_1.12.gemfile.lock b/gemfiles/jruby_9.4_graphql_1.12.gemfile.lock index dad5c3ff67c..faf0f0090f9 100644 --- a/gemfiles/jruby_9.4_graphql_1.12.gemfile.lock +++ b/gemfiles/jruby_9.4_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_graphql_1.13.gemfile.lock b/gemfiles/jruby_9.4_graphql_1.13.gemfile.lock index c62cde5bb86..2873f6d9b7e 100644 --- a/gemfiles/jruby_9.4_graphql_1.13.gemfile.lock +++ b/gemfiles/jruby_9.4_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_graphql_2.0.gemfile.lock b/gemfiles/jruby_9.4_graphql_2.0.gemfile.lock index 8af47cd4892..5d2a16b62dc 100644 --- a/gemfiles/jruby_9.4_graphql_2.0.gemfile.lock +++ b/gemfiles/jruby_9.4_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_graphql_2.1.gemfile.lock b/gemfiles/jruby_9.4_graphql_2.1.gemfile.lock index 87b24e341ed..0b7a745ac5f 100644 --- a/gemfiles/jruby_9.4_graphql_2.1.gemfile.lock +++ b/gemfiles/jruby_9.4_graphql_2.1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_graphql_2.2.gemfile.lock b/gemfiles/jruby_9.4_graphql_2.2.gemfile.lock index 3e1585f5147..da709ba0733 100644 --- a/gemfiles/jruby_9.4_graphql_2.2.gemfile.lock +++ b/gemfiles/jruby_9.4_graphql_2.2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_http.gemfile.lock b/gemfiles/jruby_9.4_http.gemfile.lock index e20183562bf..caaab88379a 100644 --- a/gemfiles/jruby_9.4_http.gemfile.lock +++ b/gemfiles/jruby_9.4_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_multi_rack_app.gemfile.lock b/gemfiles/jruby_9.4_multi_rack_app.gemfile.lock index b7fb43e815e..d1937ae56cd 100644 --- a/gemfiles/jruby_9.4_multi_rack_app.gemfile.lock +++ b/gemfiles/jruby_9.4_multi_rack_app.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_opensearch_2.gemfile.lock b/gemfiles/jruby_9.4_opensearch_2.gemfile.lock index d3e04a04558..d8fd5da41a2 100644 --- a/gemfiles/jruby_9.4_opensearch_2.gemfile.lock +++ b/gemfiles/jruby_9.4_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_opensearch_3.gemfile.lock b/gemfiles/jruby_9.4_opensearch_3.gemfile.lock index cda8469119f..73d1a6a38fc 100644 --- a/gemfiles/jruby_9.4_opensearch_3.gemfile.lock +++ b/gemfiles/jruby_9.4_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_opentracing.gemfile.lock b/gemfiles/jruby_9.4_opentracing.gemfile.lock index 4b1254bdf07..8c8cc2368b3 100644 --- a/gemfiles/jruby_9.4_opentracing.gemfile.lock +++ b/gemfiles/jruby_9.4_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_rack_1.gemfile.lock b/gemfiles/jruby_9.4_rack_1.gemfile.lock index 587d15b2151..802b93a3d68 100644 --- a/gemfiles/jruby_9.4_rack_1.gemfile.lock +++ b/gemfiles/jruby_9.4_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_rack_2.gemfile.lock b/gemfiles/jruby_9.4_rack_2.gemfile.lock index 411260c40cf..4c707c8487a 100644 --- a/gemfiles/jruby_9.4_rack_2.gemfile.lock +++ b/gemfiles/jruby_9.4_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_rack_3.gemfile.lock b/gemfiles/jruby_9.4_rack_3.gemfile.lock index 28940b141da..977ff0e5499 100644 --- a/gemfiles/jruby_9.4_rack_3.gemfile.lock +++ b/gemfiles/jruby_9.4_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_rails61_mysql2.gemfile.lock b/gemfiles/jruby_9.4_rails61_mysql2.gemfile.lock index 643cbe8ca21..6ce0135ae1c 100644 --- a/gemfiles/jruby_9.4_rails61_mysql2.gemfile.lock +++ b/gemfiles/jruby_9.4_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_rails61_postgres.gemfile.lock b/gemfiles/jruby_9.4_rails61_postgres.gemfile.lock index a4b85891d22..6629414e6ac 100644 --- a/gemfiles/jruby_9.4_rails61_postgres.gemfile.lock +++ b/gemfiles/jruby_9.4_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_rails61_postgres_redis.gemfile.lock b/gemfiles/jruby_9.4_rails61_postgres_redis.gemfile.lock index c535373c9d8..594335f1396 100644 --- a/gemfiles/jruby_9.4_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/jruby_9.4_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/jruby_9.4_rails61_postgres_sidekiq.gemfile.lock index 2a95b6114dc..e0ddcf0414b 100644 --- a/gemfiles/jruby_9.4_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/jruby_9.4_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_rails61_semantic_logger.gemfile.lock b/gemfiles/jruby_9.4_rails61_semantic_logger.gemfile.lock index 4e950e2b767..93a47d7afcb 100644 --- a/gemfiles/jruby_9.4_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/jruby_9.4_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_redis_3.gemfile.lock b/gemfiles/jruby_9.4_redis_3.gemfile.lock index 60310814601..14df3cad88f 100644 --- a/gemfiles/jruby_9.4_redis_3.gemfile.lock +++ b/gemfiles/jruby_9.4_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_redis_4.gemfile.lock b/gemfiles/jruby_9.4_redis_4.gemfile.lock index a6108e3dec2..87c5a60225f 100644 --- a/gemfiles/jruby_9.4_redis_4.gemfile.lock +++ b/gemfiles/jruby_9.4_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_redis_5.gemfile.lock b/gemfiles/jruby_9.4_redis_5.gemfile.lock index 70677f2c89a..0967f8b1dbe 100644 --- a/gemfiles/jruby_9.4_redis_5.gemfile.lock +++ b/gemfiles/jruby_9.4_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_relational_db.gemfile.lock b/gemfiles/jruby_9.4_relational_db.gemfile.lock index f87b3b5dbd8..e375b45087f 100644 --- a/gemfiles/jruby_9.4_relational_db.gemfile.lock +++ b/gemfiles/jruby_9.4_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_resque2_redis3.gemfile.lock b/gemfiles/jruby_9.4_resque2_redis3.gemfile.lock index 28103b973e5..addfb2d1112 100644 --- a/gemfiles/jruby_9.4_resque2_redis3.gemfile.lock +++ b/gemfiles/jruby_9.4_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_resque2_redis4.gemfile.lock b/gemfiles/jruby_9.4_resque2_redis4.gemfile.lock index 750c0fd2a9e..ab4b48e86db 100644 --- a/gemfiles/jruby_9.4_resque2_redis4.gemfile.lock +++ b/gemfiles/jruby_9.4_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/jruby_9.4_sinatra.gemfile.lock b/gemfiles/jruby_9.4_sinatra.gemfile.lock index fd707f24080..36934ec5ba1 100644 --- a/gemfiles/jruby_9.4_sinatra.gemfile.lock +++ b/gemfiles/jruby_9.4_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_activesupport.gemfile.lock b/gemfiles/ruby_2.1_activesupport.gemfile.lock index f1b401e2436..9267e782a36 100644 --- a/gemfiles/ruby_2.1_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.1_activesupport.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_aws.gemfile.lock b/gemfiles/ruby_2.1_aws.gemfile.lock index c0a3c44dba0..bde6c3aeaa7 100644 --- a/gemfiles/ruby_2.1_aws.gemfile.lock +++ b/gemfiles/ruby_2.1_aws.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_contrib.gemfile.lock b/gemfiles/ruby_2.1_contrib.gemfile.lock index c9476c4941c..2096a7fca38 100644 --- a/gemfiles/ruby_2.1_contrib.gemfile.lock +++ b/gemfiles/ruby_2.1_contrib.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_core_old.gemfile.lock b/gemfiles/ruby_2.1_core_old.gemfile.lock index c241a458a3f..782c8ffb4b6 100644 --- a/gemfiles/ruby_2.1_core_old.gemfile.lock +++ b/gemfiles/ruby_2.1_core_old.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_elasticsearch_7.gemfile.lock b/gemfiles/ruby_2.1_elasticsearch_7.gemfile.lock index abf6b6af3aa..1b51ca28cb9 100644 --- a/gemfiles/ruby_2.1_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_2.1_elasticsearch_7.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_http.gemfile.lock b/gemfiles/ruby_2.1_http.gemfile.lock index 8538edcbf60..fa63cb6fdf5 100644 --- a/gemfiles/ruby_2.1_http.gemfile.lock +++ b/gemfiles/ruby_2.1_http.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_opentracing.gemfile.lock b/gemfiles/ruby_2.1_opentracing.gemfile.lock index 50278aedd9e..cda6d8ecd2b 100644 --- a/gemfiles/ruby_2.1_opentracing.gemfile.lock +++ b/gemfiles/ruby_2.1_opentracing.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_rack_1.gemfile.lock b/gemfiles/ruby_2.1_rack_1.gemfile.lock index 366c52e247f..859db065123 100644 --- a/gemfiles/ruby_2.1_rack_1.gemfile.lock +++ b/gemfiles/ruby_2.1_rack_1.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_rails32_mysql2.gemfile.lock b/gemfiles/ruby_2.1_rails32_mysql2.gemfile.lock index 62e3b14004d..616b9f5d2d5 100644 --- a/gemfiles/ruby_2.1_rails32_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.1_rails32_mysql2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_rails32_postgres.gemfile.lock b/gemfiles/ruby_2.1_rails32_postgres.gemfile.lock index bbee569a25b..fade677d873 100644 --- a/gemfiles/ruby_2.1_rails32_postgres.gemfile.lock +++ b/gemfiles/ruby_2.1_rails32_postgres.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_rails32_postgres_redis.gemfile.lock b/gemfiles/ruby_2.1_rails32_postgres_redis.gemfile.lock index 8859911833f..8b385f48589 100644 --- a/gemfiles/ruby_2.1_rails32_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.1_rails32_postgres_redis.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_rails32_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.1_rails32_postgres_sidekiq.gemfile.lock index 359754b1969..07e78dbdd09 100644 --- a/gemfiles/ruby_2.1_rails32_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.1_rails32_postgres_sidekiq.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_rails4_mysql2.gemfile.lock b/gemfiles/ruby_2.1_rails4_mysql2.gemfile.lock index f6bef5376ac..f9a115f8d73 100644 --- a/gemfiles/ruby_2.1_rails4_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.1_rails4_mysql2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_rails4_postgres.gemfile.lock b/gemfiles/ruby_2.1_rails4_postgres.gemfile.lock index c1600d3ed06..9e2c8290277 100644 --- a/gemfiles/ruby_2.1_rails4_postgres.gemfile.lock +++ b/gemfiles/ruby_2.1_rails4_postgres.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_rails4_postgres_redis.gemfile.lock b/gemfiles/ruby_2.1_rails4_postgres_redis.gemfile.lock index 45ae2c1235f..f5a731781a8 100644 --- a/gemfiles/ruby_2.1_rails4_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.1_rails4_postgres_redis.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_rails4_semantic_logger.gemfile.lock b/gemfiles/ruby_2.1_rails4_semantic_logger.gemfile.lock index e866a97094d..81b8c9fc6a6 100644 --- a/gemfiles/ruby_2.1_rails4_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.1_rails4_semantic_logger.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_redis_3.gemfile.lock b/gemfiles/ruby_2.1_redis_3.gemfile.lock index 51afb2c44a2..32f18a49e54 100644 --- a/gemfiles/ruby_2.1_redis_3.gemfile.lock +++ b/gemfiles/ruby_2.1_redis_3.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_relational_db.gemfile.lock b/gemfiles/ruby_2.1_relational_db.gemfile.lock index 46889c707e1..17bdd406d1c 100644 --- a/gemfiles/ruby_2.1_relational_db.gemfile.lock +++ b/gemfiles/ruby_2.1_relational_db.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.1_sinatra.gemfile.lock b/gemfiles/ruby_2.1_sinatra.gemfile.lock index 47bab5a1719..2a9d779dc96 100644 --- a/gemfiles/ruby_2.1_sinatra.gemfile.lock +++ b/gemfiles/ruby_2.1_sinatra.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_activesupport.gemfile.lock b/gemfiles/ruby_2.2_activesupport.gemfile.lock index 970311a00ea..c299de25cd0 100644 --- a/gemfiles/ruby_2.2_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.2_activesupport.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_aws.gemfile.lock b/gemfiles/ruby_2.2_aws.gemfile.lock index 038c1277ae0..ce47387c564 100644 --- a/gemfiles/ruby_2.2_aws.gemfile.lock +++ b/gemfiles/ruby_2.2_aws.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_contrib.gemfile.lock b/gemfiles/ruby_2.2_contrib.gemfile.lock index a86e6419085..69eeba2eee4 100644 --- a/gemfiles/ruby_2.2_contrib.gemfile.lock +++ b/gemfiles/ruby_2.2_contrib.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_core_old.gemfile.lock b/gemfiles/ruby_2.2_core_old.gemfile.lock index ae4f504cf16..f91acaa2c2c 100644 --- a/gemfiles/ruby_2.2_core_old.gemfile.lock +++ b/gemfiles/ruby_2.2_core_old.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_elasticsearch_7.gemfile.lock b/gemfiles/ruby_2.2_elasticsearch_7.gemfile.lock index 6d3d16503e8..34f4e55322a 100644 --- a/gemfiles/ruby_2.2_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_2.2_elasticsearch_7.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_graphql_1.12.gemfile.lock b/gemfiles/ruby_2.2_graphql_1.12.gemfile.lock index 1b94d238ddd..1046406bab9 100644 --- a/gemfiles/ruby_2.2_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_2.2_graphql_1.12.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_http.gemfile.lock b/gemfiles/ruby_2.2_http.gemfile.lock index a8a6b4ef7ac..440e63b14df 100644 --- a/gemfiles/ruby_2.2_http.gemfile.lock +++ b/gemfiles/ruby_2.2_http.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_opentracing.gemfile.lock b/gemfiles/ruby_2.2_opentracing.gemfile.lock index 61c7416bc70..f093496e817 100644 --- a/gemfiles/ruby_2.2_opentracing.gemfile.lock +++ b/gemfiles/ruby_2.2_opentracing.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rack_1.gemfile.lock b/gemfiles/ruby_2.2_rack_1.gemfile.lock index 4b8853106fa..c0b0186623b 100644 --- a/gemfiles/ruby_2.2_rack_1.gemfile.lock +++ b/gemfiles/ruby_2.2_rack_1.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails32_mysql2.gemfile.lock b/gemfiles/ruby_2.2_rails32_mysql2.gemfile.lock index c9d4206b2db..f7aad48e9c0 100644 --- a/gemfiles/ruby_2.2_rails32_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.2_rails32_mysql2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails32_postgres.gemfile.lock b/gemfiles/ruby_2.2_rails32_postgres.gemfile.lock index 15fa2006241..fcd67026fdc 100644 --- a/gemfiles/ruby_2.2_rails32_postgres.gemfile.lock +++ b/gemfiles/ruby_2.2_rails32_postgres.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails32_postgres_redis.gemfile.lock b/gemfiles/ruby_2.2_rails32_postgres_redis.gemfile.lock index 969a8f08ba0..1c75ef8d67a 100644 --- a/gemfiles/ruby_2.2_rails32_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.2_rails32_postgres_redis.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails32_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.2_rails32_postgres_sidekiq.gemfile.lock index ad370098bce..53cf51c04bd 100644 --- a/gemfiles/ruby_2.2_rails32_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.2_rails32_postgres_sidekiq.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails4_mysql2.gemfile.lock b/gemfiles/ruby_2.2_rails4_mysql2.gemfile.lock index bb7c63dd4a1..3eb144c63ca 100644 --- a/gemfiles/ruby_2.2_rails4_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.2_rails4_mysql2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails4_postgres.gemfile.lock b/gemfiles/ruby_2.2_rails4_postgres.gemfile.lock index b559f657867..ea2520ab0f8 100644 --- a/gemfiles/ruby_2.2_rails4_postgres.gemfile.lock +++ b/gemfiles/ruby_2.2_rails4_postgres.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails4_postgres_redis.gemfile.lock b/gemfiles/ruby_2.2_rails4_postgres_redis.gemfile.lock index 9e1b081220f..50597395de4 100644 --- a/gemfiles/ruby_2.2_rails4_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.2_rails4_postgres_redis.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails4_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.2_rails4_postgres_sidekiq.gemfile.lock index 4d3c77b6a66..4fe9e8e403c 100644 --- a/gemfiles/ruby_2.2_rails4_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.2_rails4_postgres_sidekiq.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails4_semantic_logger.gemfile.lock b/gemfiles/ruby_2.2_rails4_semantic_logger.gemfile.lock index 011598da7af..eb15f0664a4 100644 --- a/gemfiles/ruby_2.2_rails4_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.2_rails4_semantic_logger.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails5_mysql2.gemfile.lock b/gemfiles/ruby_2.2_rails5_mysql2.gemfile.lock index b0287017355..d5273810dcc 100644 --- a/gemfiles/ruby_2.2_rails5_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.2_rails5_mysql2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails5_postgres.gemfile.lock b/gemfiles/ruby_2.2_rails5_postgres.gemfile.lock index 54b8b3010aa..a185e88d097 100644 --- a/gemfiles/ruby_2.2_rails5_postgres.gemfile.lock +++ b/gemfiles/ruby_2.2_rails5_postgres.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails5_postgres_redis.gemfile.lock b/gemfiles/ruby_2.2_rails5_postgres_redis.gemfile.lock index 97964583a9f..4b129938ebf 100644 --- a/gemfiles/ruby_2.2_rails5_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.2_rails5_postgres_redis.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails5_postgres_redis_activesupport.gemfile.lock b/gemfiles/ruby_2.2_rails5_postgres_redis_activesupport.gemfile.lock index 2bf66fec2a6..9ed9b725cb7 100644 --- a/gemfiles/ruby_2.2_rails5_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.2_rails5_postgres_redis_activesupport.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails5_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.2_rails5_postgres_sidekiq.gemfile.lock index 5f0f4f4f639..4e5a3fddae0 100644 --- a/gemfiles/ruby_2.2_rails5_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.2_rails5_postgres_sidekiq.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_rails5_semantic_logger.gemfile.lock b/gemfiles/ruby_2.2_rails5_semantic_logger.gemfile.lock index 5f5fc3f14b4..d502b814ab4 100644 --- a/gemfiles/ruby_2.2_rails5_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.2_rails5_semantic_logger.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_redis_3.gemfile.lock b/gemfiles/ruby_2.2_redis_3.gemfile.lock index c33d6523bf9..fba85839095 100644 --- a/gemfiles/ruby_2.2_redis_3.gemfile.lock +++ b/gemfiles/ruby_2.2_redis_3.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_relational_db.gemfile.lock b/gemfiles/ruby_2.2_relational_db.gemfile.lock index fe5de5869f8..fe6eeef8164 100644 --- a/gemfiles/ruby_2.2_relational_db.gemfile.lock +++ b/gemfiles/ruby_2.2_relational_db.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.2_sinatra.gemfile.lock b/gemfiles/ruby_2.2_sinatra.gemfile.lock index f466ce39bcd..fc192f7a422 100644 --- a/gemfiles/ruby_2.2_sinatra.gemfile.lock +++ b/gemfiles/ruby_2.2_sinatra.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_activerecord_3.gemfile.lock b/gemfiles/ruby_2.3_activerecord_3.gemfile.lock index 43858651f59..a9c4c1263ad 100644 --- a/gemfiles/ruby_2.3_activerecord_3.gemfile.lock +++ b/gemfiles/ruby_2.3_activerecord_3.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_activesupport.gemfile.lock b/gemfiles/ruby_2.3_activesupport.gemfile.lock index 4245bdbb95d..299aac1c397 100644 --- a/gemfiles/ruby_2.3_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.3_activesupport.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_aws.gemfile.lock b/gemfiles/ruby_2.3_aws.gemfile.lock index 2c4c3050c3a..32146074bbf 100644 --- a/gemfiles/ruby_2.3_aws.gemfile.lock +++ b/gemfiles/ruby_2.3_aws.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_contrib.gemfile.lock b/gemfiles/ruby_2.3_contrib.gemfile.lock index a9e5bfeeedb..065388008d8 100644 --- a/gemfiles/ruby_2.3_contrib.gemfile.lock +++ b/gemfiles/ruby_2.3_contrib.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_contrib_old.gemfile.lock b/gemfiles/ruby_2.3_contrib_old.gemfile.lock index aaa875b7b26..969b7d2237e 100644 --- a/gemfiles/ruby_2.3_contrib_old.gemfile.lock +++ b/gemfiles/ruby_2.3_contrib_old.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_core_old.gemfile.lock b/gemfiles/ruby_2.3_core_old.gemfile.lock index cd02e2b78f8..391d1487f89 100644 --- a/gemfiles/ruby_2.3_core_old.gemfile.lock +++ b/gemfiles/ruby_2.3_core_old.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_elasticsearch_7.gemfile.lock b/gemfiles/ruby_2.3_elasticsearch_7.gemfile.lock index d59c506085a..ae141811cce 100644 --- a/gemfiles/ruby_2.3_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_2.3_elasticsearch_7.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_graphql_1.12.gemfile.lock b/gemfiles/ruby_2.3_graphql_1.12.gemfile.lock index d296bca4a7f..7c1978a1564 100644 --- a/gemfiles/ruby_2.3_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_2.3_graphql_1.12.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_hanami_1.gemfile.lock b/gemfiles/ruby_2.3_hanami_1.gemfile.lock index 411abf6af9e..580beaf89bc 100644 --- a/gemfiles/ruby_2.3_hanami_1.gemfile.lock +++ b/gemfiles/ruby_2.3_hanami_1.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_http.gemfile.lock b/gemfiles/ruby_2.3_http.gemfile.lock index 315a3fef4e2..c1591ce1fe7 100644 --- a/gemfiles/ruby_2.3_http.gemfile.lock +++ b/gemfiles/ruby_2.3_http.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_opentracing.gemfile.lock b/gemfiles/ruby_2.3_opentracing.gemfile.lock index 265155a8ef6..7766398a4d7 100644 --- a/gemfiles/ruby_2.3_opentracing.gemfile.lock +++ b/gemfiles/ruby_2.3_opentracing.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rack_1.gemfile.lock b/gemfiles/ruby_2.3_rack_1.gemfile.lock index e57f8e4bca2..2005346864f 100644 --- a/gemfiles/ruby_2.3_rack_1.gemfile.lock +++ b/gemfiles/ruby_2.3_rack_1.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rack_2.gemfile.lock b/gemfiles/ruby_2.3_rack_2.gemfile.lock index 1af281ab487..7bbc1c409dc 100644 --- a/gemfiles/ruby_2.3_rack_2.gemfile.lock +++ b/gemfiles/ruby_2.3_rack_2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails32_mysql2.gemfile.lock b/gemfiles/ruby_2.3_rails32_mysql2.gemfile.lock index ee0b9502770..cd52780df8c 100644 --- a/gemfiles/ruby_2.3_rails32_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.3_rails32_mysql2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails32_postgres.gemfile.lock b/gemfiles/ruby_2.3_rails32_postgres.gemfile.lock index a632d62f5f9..2f7f12db9ea 100644 --- a/gemfiles/ruby_2.3_rails32_postgres.gemfile.lock +++ b/gemfiles/ruby_2.3_rails32_postgres.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails32_postgres_redis.gemfile.lock b/gemfiles/ruby_2.3_rails32_postgres_redis.gemfile.lock index 05d67fd1ad5..87003da8130 100644 --- a/gemfiles/ruby_2.3_rails32_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.3_rails32_postgres_redis.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails32_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.3_rails32_postgres_sidekiq.gemfile.lock index 94e00bf629a..6dbc6aee955 100644 --- a/gemfiles/ruby_2.3_rails32_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.3_rails32_postgres_sidekiq.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails4_mysql2.gemfile.lock b/gemfiles/ruby_2.3_rails4_mysql2.gemfile.lock index cf73efeb2c0..d7d7f95f2d0 100644 --- a/gemfiles/ruby_2.3_rails4_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.3_rails4_mysql2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails4_postgres.gemfile.lock b/gemfiles/ruby_2.3_rails4_postgres.gemfile.lock index 2c590cf53cd..19f898f27b5 100644 --- a/gemfiles/ruby_2.3_rails4_postgres.gemfile.lock +++ b/gemfiles/ruby_2.3_rails4_postgres.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails4_postgres_redis.gemfile.lock b/gemfiles/ruby_2.3_rails4_postgres_redis.gemfile.lock index 5372eb3c926..823ec080215 100644 --- a/gemfiles/ruby_2.3_rails4_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.3_rails4_postgres_redis.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails4_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.3_rails4_postgres_sidekiq.gemfile.lock index 9dcad75be1d..d38e6136056 100644 --- a/gemfiles/ruby_2.3_rails4_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.3_rails4_postgres_sidekiq.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails4_semantic_logger.gemfile.lock b/gemfiles/ruby_2.3_rails4_semantic_logger.gemfile.lock index 4741e02d2ba..de51e07e333 100644 --- a/gemfiles/ruby_2.3_rails4_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.3_rails4_semantic_logger.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails5_mysql2.gemfile.lock b/gemfiles/ruby_2.3_rails5_mysql2.gemfile.lock index 74693004b76..0f2c92f61d0 100644 --- a/gemfiles/ruby_2.3_rails5_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.3_rails5_mysql2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails5_postgres.gemfile.lock b/gemfiles/ruby_2.3_rails5_postgres.gemfile.lock index b2a58a27b04..6f789f77952 100644 --- a/gemfiles/ruby_2.3_rails5_postgres.gemfile.lock +++ b/gemfiles/ruby_2.3_rails5_postgres.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails5_postgres_redis.gemfile.lock b/gemfiles/ruby_2.3_rails5_postgres_redis.gemfile.lock index f8b669e0388..6538b5ceec7 100644 --- a/gemfiles/ruby_2.3_rails5_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.3_rails5_postgres_redis.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails5_postgres_redis_activesupport.gemfile.lock b/gemfiles/ruby_2.3_rails5_postgres_redis_activesupport.gemfile.lock index 930e48f33dc..a0bc783e5e1 100644 --- a/gemfiles/ruby_2.3_rails5_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.3_rails5_postgres_redis_activesupport.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails5_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.3_rails5_postgres_sidekiq.gemfile.lock index 0e20b1e48d9..aa36daa00f0 100644 --- a/gemfiles/ruby_2.3_rails5_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.3_rails5_postgres_sidekiq.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_rails5_semantic_logger.gemfile.lock b/gemfiles/ruby_2.3_rails5_semantic_logger.gemfile.lock index c1b870e4687..d873974245a 100644 --- a/gemfiles/ruby_2.3_rails5_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.3_rails5_semantic_logger.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_redis_3.gemfile.lock b/gemfiles/ruby_2.3_redis_3.gemfile.lock index 79ad04e06de..bb1c24ed7be 100644 --- a/gemfiles/ruby_2.3_redis_3.gemfile.lock +++ b/gemfiles/ruby_2.3_redis_3.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_relational_db.gemfile.lock b/gemfiles/ruby_2.3_relational_db.gemfile.lock index 2a171516244..4a8e1609932 100644 --- a/gemfiles/ruby_2.3_relational_db.gemfile.lock +++ b/gemfiles/ruby_2.3_relational_db.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_resque2_redis3.gemfile.lock b/gemfiles/ruby_2.3_resque2_redis3.gemfile.lock index 5e57d7b36e9..824e4e52a0e 100644 --- a/gemfiles/ruby_2.3_resque2_redis3.gemfile.lock +++ b/gemfiles/ruby_2.3_resque2_redis3.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_resque2_redis4.gemfile.lock b/gemfiles/ruby_2.3_resque2_redis4.gemfile.lock index c3158bcfffb..00f55432ba9 100644 --- a/gemfiles/ruby_2.3_resque2_redis4.gemfile.lock +++ b/gemfiles/ruby_2.3_resque2_redis4.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.3_sinatra.gemfile.lock b/gemfiles/ruby_2.3_sinatra.gemfile.lock index b5cfd32bcdd..d2c21bd3c5c 100644 --- a/gemfiles/ruby_2.3_sinatra.gemfile.lock +++ b/gemfiles/ruby_2.3_sinatra.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_activerecord_4.gemfile.lock b/gemfiles/ruby_2.4_activerecord_4.gemfile.lock index 7a820ac4fa3..2ad886939dc 100644 --- a/gemfiles/ruby_2.4_activerecord_4.gemfile.lock +++ b/gemfiles/ruby_2.4_activerecord_4.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_activesupport.gemfile.lock b/gemfiles/ruby_2.4_activesupport.gemfile.lock index 5b9e17b6dd3..03ef5624455 100644 --- a/gemfiles/ruby_2.4_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.4_activesupport.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_aws.gemfile.lock b/gemfiles/ruby_2.4_aws.gemfile.lock index 548154b5c3e..bb0d42c4852 100644 --- a/gemfiles/ruby_2.4_aws.gemfile.lock +++ b/gemfiles/ruby_2.4_aws.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_contrib.gemfile.lock b/gemfiles/ruby_2.4_contrib.gemfile.lock index 4c204c251af..da64ad87e01 100644 --- a/gemfiles/ruby_2.4_contrib.gemfile.lock +++ b/gemfiles/ruby_2.4_contrib.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_contrib_old.gemfile.lock b/gemfiles/ruby_2.4_contrib_old.gemfile.lock index e24a68ffae6..e240fbdcbc5 100644 --- a/gemfiles/ruby_2.4_contrib_old.gemfile.lock +++ b/gemfiles/ruby_2.4_contrib_old.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_core_old.gemfile.lock b/gemfiles/ruby_2.4_core_old.gemfile.lock index d8c4c914aa9..6b1bd7ccb3b 100644 --- a/gemfiles/ruby_2.4_core_old.gemfile.lock +++ b/gemfiles/ruby_2.4_core_old.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_elasticsearch_7.gemfile.lock b/gemfiles/ruby_2.4_elasticsearch_7.gemfile.lock index 5e54c96be03..064443d7fab 100644 --- a/gemfiles/ruby_2.4_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_2.4_elasticsearch_7.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_graphql_1.12.gemfile.lock b/gemfiles/ruby_2.4_graphql_1.12.gemfile.lock index 3d32cba241f..2efbd88ee44 100644 --- a/gemfiles/ruby_2.4_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_2.4_graphql_1.12.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_graphql_1.13.gemfile.lock b/gemfiles/ruby_2.4_graphql_1.13.gemfile.lock index 5cbd9a2172f..db37eeb5b13 100644 --- a/gemfiles/ruby_2.4_graphql_1.13.gemfile.lock +++ b/gemfiles/ruby_2.4_graphql_1.13.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_graphql_2.0.gemfile.lock b/gemfiles/ruby_2.4_graphql_2.0.gemfile.lock index 2650b1c9e9a..a06abbb2394 100644 --- a/gemfiles/ruby_2.4_graphql_2.0.gemfile.lock +++ b/gemfiles/ruby_2.4_graphql_2.0.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_hanami_1.gemfile.lock b/gemfiles/ruby_2.4_hanami_1.gemfile.lock index 8d76ff5c72c..67df8a28828 100644 --- a/gemfiles/ruby_2.4_hanami_1.gemfile.lock +++ b/gemfiles/ruby_2.4_hanami_1.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_http.gemfile.lock b/gemfiles/ruby_2.4_http.gemfile.lock index 2c9199802c0..e245809ab44 100644 --- a/gemfiles/ruby_2.4_http.gemfile.lock +++ b/gemfiles/ruby_2.4_http.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_opensearch_2.gemfile.lock b/gemfiles/ruby_2.4_opensearch_2.gemfile.lock index 622b507adad..232a803f8ee 100644 --- a/gemfiles/ruby_2.4_opensearch_2.gemfile.lock +++ b/gemfiles/ruby_2.4_opensearch_2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_opentracing.gemfile.lock b/gemfiles/ruby_2.4_opentracing.gemfile.lock index bfb60a62a44..452e76e776a 100644 --- a/gemfiles/ruby_2.4_opentracing.gemfile.lock +++ b/gemfiles/ruby_2.4_opentracing.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_rack_1.gemfile.lock b/gemfiles/ruby_2.4_rack_1.gemfile.lock index 0fa23c8f738..c78bc9aa898 100644 --- a/gemfiles/ruby_2.4_rack_1.gemfile.lock +++ b/gemfiles/ruby_2.4_rack_1.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_rack_2.gemfile.lock b/gemfiles/ruby_2.4_rack_2.gemfile.lock index 41de2b84f7f..6055cd1d659 100644 --- a/gemfiles/ruby_2.4_rack_2.gemfile.lock +++ b/gemfiles/ruby_2.4_rack_2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_rack_3.gemfile.lock b/gemfiles/ruby_2.4_rack_3.gemfile.lock index 0810d3f5dc1..ea5ecd9fedb 100644 --- a/gemfiles/ruby_2.4_rack_3.gemfile.lock +++ b/gemfiles/ruby_2.4_rack_3.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_rails5_mysql2.gemfile.lock b/gemfiles/ruby_2.4_rails5_mysql2.gemfile.lock index 923b42b5aab..fbab1d0c394 100644 --- a/gemfiles/ruby_2.4_rails5_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.4_rails5_mysql2.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_rails5_postgres.gemfile.lock b/gemfiles/ruby_2.4_rails5_postgres.gemfile.lock index cb4c40269b5..4b2c63dbef5 100644 --- a/gemfiles/ruby_2.4_rails5_postgres.gemfile.lock +++ b/gemfiles/ruby_2.4_rails5_postgres.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_rails5_postgres_redis.gemfile.lock b/gemfiles/ruby_2.4_rails5_postgres_redis.gemfile.lock index f8f0f6d4fba..59cb67f6f05 100644 --- a/gemfiles/ruby_2.4_rails5_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.4_rails5_postgres_redis.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_rails5_postgres_redis_activesupport.gemfile.lock b/gemfiles/ruby_2.4_rails5_postgres_redis_activesupport.gemfile.lock index d89393b964e..add60dc6ce0 100644 --- a/gemfiles/ruby_2.4_rails5_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.4_rails5_postgres_redis_activesupport.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_rails5_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.4_rails5_postgres_sidekiq.gemfile.lock index b817005504f..0dfa989fd34 100644 --- a/gemfiles/ruby_2.4_rails5_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.4_rails5_postgres_sidekiq.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_rails5_semantic_logger.gemfile.lock b/gemfiles/ruby_2.4_rails5_semantic_logger.gemfile.lock index 477d83a254d..0502cdf2c26 100644 --- a/gemfiles/ruby_2.4_rails5_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.4_rails5_semantic_logger.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_redis_3.gemfile.lock b/gemfiles/ruby_2.4_redis_3.gemfile.lock index ade5e019039..33781e947e2 100644 --- a/gemfiles/ruby_2.4_redis_3.gemfile.lock +++ b/gemfiles/ruby_2.4_redis_3.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_redis_4.gemfile.lock b/gemfiles/ruby_2.4_redis_4.gemfile.lock index 72b7d671899..669fb4bf179 100644 --- a/gemfiles/ruby_2.4_redis_4.gemfile.lock +++ b/gemfiles/ruby_2.4_redis_4.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_relational_db.gemfile.lock b/gemfiles/ruby_2.4_relational_db.gemfile.lock index 4b02d6758c3..c1418204ad5 100644 --- a/gemfiles/ruby_2.4_relational_db.gemfile.lock +++ b/gemfiles/ruby_2.4_relational_db.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_resque2_redis3.gemfile.lock b/gemfiles/ruby_2.4_resque2_redis3.gemfile.lock index 88cc461440c..ee361543e2f 100644 --- a/gemfiles/ruby_2.4_resque2_redis3.gemfile.lock +++ b/gemfiles/ruby_2.4_resque2_redis3.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_resque2_redis4.gemfile.lock b/gemfiles/ruby_2.4_resque2_redis4.gemfile.lock index 9fa6761858a..bb844f89888 100644 --- a/gemfiles/ruby_2.4_resque2_redis4.gemfile.lock +++ b/gemfiles/ruby_2.4_resque2_redis4.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.4_sinatra.gemfile.lock b/gemfiles/ruby_2.4_sinatra.gemfile.lock index 6594932717c..c205c3edeb6 100644 --- a/gemfiles/ruby_2.4_sinatra.gemfile.lock +++ b/gemfiles/ruby_2.4_sinatra.gemfile.lock @@ -1,7 +1,7 @@ PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_activesupport.gemfile.lock b/gemfiles/ruby_2.5_activesupport.gemfile.lock index fb688d20f8d..ae780bd77a5 100644 --- a/gemfiles/ruby_2.5_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.5_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_aws.gemfile.lock b/gemfiles/ruby_2.5_aws.gemfile.lock index 66845f23dde..d5bd9643799 100644 --- a/gemfiles/ruby_2.5_aws.gemfile.lock +++ b/gemfiles/ruby_2.5_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_contrib.gemfile.lock b/gemfiles/ruby_2.5_contrib.gemfile.lock index ed9ba4610bf..bf75ef22658 100644 --- a/gemfiles/ruby_2.5_contrib.gemfile.lock +++ b/gemfiles/ruby_2.5_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_contrib_old.gemfile.lock b/gemfiles/ruby_2.5_contrib_old.gemfile.lock index 5e67e8b8d71..351b609bcba 100644 --- a/gemfiles/ruby_2.5_contrib_old.gemfile.lock +++ b/gemfiles/ruby_2.5_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_core_old.gemfile.lock b/gemfiles/ruby_2.5_core_old.gemfile.lock index 93c859ff39a..4eb5a2d4b7c 100644 --- a/gemfiles/ruby_2.5_core_old.gemfile.lock +++ b/gemfiles/ruby_2.5_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_elasticsearch_7.gemfile.lock b/gemfiles/ruby_2.5_elasticsearch_7.gemfile.lock index a89657cb2b4..d32fab1a454 100644 --- a/gemfiles/ruby_2.5_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_2.5_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_elasticsearch_8.gemfile.lock b/gemfiles/ruby_2.5_elasticsearch_8.gemfile.lock index ea4c61eede0..9c44f41e4f5 100644 --- a/gemfiles/ruby_2.5_elasticsearch_8.gemfile.lock +++ b/gemfiles/ruby_2.5_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_graphql_1.12.gemfile.lock b/gemfiles/ruby_2.5_graphql_1.12.gemfile.lock index b7d113546a1..7ec6159446c 100644 --- a/gemfiles/ruby_2.5_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_2.5_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_graphql_1.13.gemfile.lock b/gemfiles/ruby_2.5_graphql_1.13.gemfile.lock index b9f81c20741..9e1dad49b4e 100644 --- a/gemfiles/ruby_2.5_graphql_1.13.gemfile.lock +++ b/gemfiles/ruby_2.5_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_graphql_2.0.gemfile.lock b/gemfiles/ruby_2.5_graphql_2.0.gemfile.lock index 1a92917a0ea..048a932edb5 100644 --- a/gemfiles/ruby_2.5_graphql_2.0.gemfile.lock +++ b/gemfiles/ruby_2.5_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_hanami_1.gemfile.lock b/gemfiles/ruby_2.5_hanami_1.gemfile.lock index e861bd041d4..a08fd6b8a91 100644 --- a/gemfiles/ruby_2.5_hanami_1.gemfile.lock +++ b/gemfiles/ruby_2.5_hanami_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_http.gemfile.lock b/gemfiles/ruby_2.5_http.gemfile.lock index 2f460cc6c84..8e5b7f4626d 100644 --- a/gemfiles/ruby_2.5_http.gemfile.lock +++ b/gemfiles/ruby_2.5_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_multi_rack_app.gemfile.lock b/gemfiles/ruby_2.5_multi_rack_app.gemfile.lock index b0269051576..70e2a053550 100644 --- a/gemfiles/ruby_2.5_multi_rack_app.gemfile.lock +++ b/gemfiles/ruby_2.5_multi_rack_app.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_opensearch_2.gemfile.lock b/gemfiles/ruby_2.5_opensearch_2.gemfile.lock index dd5f638046d..740c7ec8055 100644 --- a/gemfiles/ruby_2.5_opensearch_2.gemfile.lock +++ b/gemfiles/ruby_2.5_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_opensearch_3.gemfile.lock b/gemfiles/ruby_2.5_opensearch_3.gemfile.lock index 7470718f08a..8a03ae1a4d4 100644 --- a/gemfiles/ruby_2.5_opensearch_3.gemfile.lock +++ b/gemfiles/ruby_2.5_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_opentracing.gemfile.lock b/gemfiles/ruby_2.5_opentracing.gemfile.lock index db173c802df..c2895cf5a34 100644 --- a/gemfiles/ruby_2.5_opentracing.gemfile.lock +++ b/gemfiles/ruby_2.5_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rack_1.gemfile.lock b/gemfiles/ruby_2.5_rack_1.gemfile.lock index 51a112cfad6..3a7627e7119 100644 --- a/gemfiles/ruby_2.5_rack_1.gemfile.lock +++ b/gemfiles/ruby_2.5_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rack_2.gemfile.lock b/gemfiles/ruby_2.5_rack_2.gemfile.lock index 93fd030c2ba..acba9af1ca3 100644 --- a/gemfiles/ruby_2.5_rack_2.gemfile.lock +++ b/gemfiles/ruby_2.5_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rack_3.gemfile.lock b/gemfiles/ruby_2.5_rack_3.gemfile.lock index f34b25deed1..2cbc69de15f 100644 --- a/gemfiles/ruby_2.5_rack_3.gemfile.lock +++ b/gemfiles/ruby_2.5_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails5_mysql2.gemfile.lock b/gemfiles/ruby_2.5_rails5_mysql2.gemfile.lock index 7e853e5e5f3..630766dc81a 100644 --- a/gemfiles/ruby_2.5_rails5_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.5_rails5_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails5_postgres.gemfile.lock b/gemfiles/ruby_2.5_rails5_postgres.gemfile.lock index 6d2d6ef51a0..cbc5eefb4c8 100644 --- a/gemfiles/ruby_2.5_rails5_postgres.gemfile.lock +++ b/gemfiles/ruby_2.5_rails5_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails5_postgres_redis.gemfile.lock b/gemfiles/ruby_2.5_rails5_postgres_redis.gemfile.lock index 841bbf4804b..104181038d5 100644 --- a/gemfiles/ruby_2.5_rails5_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.5_rails5_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails5_postgres_redis_activesupport.gemfile.lock b/gemfiles/ruby_2.5_rails5_postgres_redis_activesupport.gemfile.lock index 0400bff2f0e..cc9efab079c 100644 --- a/gemfiles/ruby_2.5_rails5_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.5_rails5_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails5_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.5_rails5_postgres_sidekiq.gemfile.lock index 93cb17508fb..aa586e475a5 100644 --- a/gemfiles/ruby_2.5_rails5_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.5_rails5_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails5_semantic_logger.gemfile.lock b/gemfiles/ruby_2.5_rails5_semantic_logger.gemfile.lock index 1e459ef869f..35155f2c25a 100644 --- a/gemfiles/ruby_2.5_rails5_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.5_rails5_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails61_mysql2.gemfile.lock b/gemfiles/ruby_2.5_rails61_mysql2.gemfile.lock index ed049632131..9b7621ac9dc 100644 --- a/gemfiles/ruby_2.5_rails61_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.5_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails61_postgres.gemfile.lock b/gemfiles/ruby_2.5_rails61_postgres.gemfile.lock index bc9b1a25ffb..747d4424625 100644 --- a/gemfiles/ruby_2.5_rails61_postgres.gemfile.lock +++ b/gemfiles/ruby_2.5_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails61_postgres_redis.gemfile.lock b/gemfiles/ruby_2.5_rails61_postgres_redis.gemfile.lock index fe8fc6612bb..1bd1e4db91a 100644 --- a/gemfiles/ruby_2.5_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.5_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.5_rails61_postgres_sidekiq.gemfile.lock index cdca3e6c68c..a6ac8762028 100644 --- a/gemfiles/ruby_2.5_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.5_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails61_semantic_logger.gemfile.lock b/gemfiles/ruby_2.5_rails61_semantic_logger.gemfile.lock index 1db5aa537a4..a273a3ba111 100644 --- a/gemfiles/ruby_2.5_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.5_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails6_mysql2.gemfile.lock b/gemfiles/ruby_2.5_rails6_mysql2.gemfile.lock index f3f3b03b8a8..08cbd14d77b 100644 --- a/gemfiles/ruby_2.5_rails6_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.5_rails6_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails6_postgres.gemfile.lock b/gemfiles/ruby_2.5_rails6_postgres.gemfile.lock index f675e955b7d..e65c0f389aa 100644 --- a/gemfiles/ruby_2.5_rails6_postgres.gemfile.lock +++ b/gemfiles/ruby_2.5_rails6_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails6_postgres_redis.gemfile.lock b/gemfiles/ruby_2.5_rails6_postgres_redis.gemfile.lock index 17aa3b4ae40..14d28810e03 100644 --- a/gemfiles/ruby_2.5_rails6_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.5_rails6_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails6_postgres_redis_activesupport.gemfile.lock b/gemfiles/ruby_2.5_rails6_postgres_redis_activesupport.gemfile.lock index 579b6cbb856..4769dbd7ff5 100644 --- a/gemfiles/ruby_2.5_rails6_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.5_rails6_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails6_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.5_rails6_postgres_sidekiq.gemfile.lock index 504ad3cae9b..a16dfe29f3f 100644 --- a/gemfiles/ruby_2.5_rails6_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.5_rails6_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_rails6_semantic_logger.gemfile.lock b/gemfiles/ruby_2.5_rails6_semantic_logger.gemfile.lock index d1540bdedc7..38b1aeed4ff 100644 --- a/gemfiles/ruby_2.5_rails6_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.5_rails6_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_redis_3.gemfile.lock b/gemfiles/ruby_2.5_redis_3.gemfile.lock index 7f17223dbce..39ff914f47f 100644 --- a/gemfiles/ruby_2.5_redis_3.gemfile.lock +++ b/gemfiles/ruby_2.5_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_redis_4.gemfile.lock b/gemfiles/ruby_2.5_redis_4.gemfile.lock index 218f93af81e..745068ba8a5 100644 --- a/gemfiles/ruby_2.5_redis_4.gemfile.lock +++ b/gemfiles/ruby_2.5_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_redis_5.gemfile.lock b/gemfiles/ruby_2.5_redis_5.gemfile.lock index e2d7b9f52fd..52d397b6fc5 100644 --- a/gemfiles/ruby_2.5_redis_5.gemfile.lock +++ b/gemfiles/ruby_2.5_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_relational_db.gemfile.lock b/gemfiles/ruby_2.5_relational_db.gemfile.lock index 56d5d301fa4..8951f32b1c6 100644 --- a/gemfiles/ruby_2.5_relational_db.gemfile.lock +++ b/gemfiles/ruby_2.5_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_resque2_redis3.gemfile.lock b/gemfiles/ruby_2.5_resque2_redis3.gemfile.lock index d2335371fdb..cfcb44fe83e 100644 --- a/gemfiles/ruby_2.5_resque2_redis3.gemfile.lock +++ b/gemfiles/ruby_2.5_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_resque2_redis4.gemfile.lock b/gemfiles/ruby_2.5_resque2_redis4.gemfile.lock index 5165795169b..1a2d80bf6fc 100644 --- a/gemfiles/ruby_2.5_resque2_redis4.gemfile.lock +++ b/gemfiles/ruby_2.5_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.5_sinatra.gemfile.lock b/gemfiles/ruby_2.5_sinatra.gemfile.lock index e963643d80e..eaf5411df07 100644 --- a/gemfiles/ruby_2.5_sinatra.gemfile.lock +++ b/gemfiles/ruby_2.5_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_activesupport.gemfile.lock b/gemfiles/ruby_2.6_activesupport.gemfile.lock index 540bb1f509f..3487f8c0ce3 100644 --- a/gemfiles/ruby_2.6_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.6_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_aws.gemfile.lock b/gemfiles/ruby_2.6_aws.gemfile.lock index 45f5de9f611..2b6ebac164f 100644 --- a/gemfiles/ruby_2.6_aws.gemfile.lock +++ b/gemfiles/ruby_2.6_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_contrib.gemfile.lock b/gemfiles/ruby_2.6_contrib.gemfile.lock index d80e64ee20c..eef3c2dad37 100644 --- a/gemfiles/ruby_2.6_contrib.gemfile.lock +++ b/gemfiles/ruby_2.6_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_contrib_old.gemfile.lock b/gemfiles/ruby_2.6_contrib_old.gemfile.lock index 4ee02635b36..2ddde19365d 100644 --- a/gemfiles/ruby_2.6_contrib_old.gemfile.lock +++ b/gemfiles/ruby_2.6_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_core_old.gemfile.lock b/gemfiles/ruby_2.6_core_old.gemfile.lock index 87e2e3f854e..598943a9092 100644 --- a/gemfiles/ruby_2.6_core_old.gemfile.lock +++ b/gemfiles/ruby_2.6_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_elasticsearch_7.gemfile.lock b/gemfiles/ruby_2.6_elasticsearch_7.gemfile.lock index fe02b7164d4..f1190623619 100644 --- a/gemfiles/ruby_2.6_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_2.6_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_elasticsearch_8.gemfile.lock b/gemfiles/ruby_2.6_elasticsearch_8.gemfile.lock index e0757d26685..89d23b0388d 100644 --- a/gemfiles/ruby_2.6_elasticsearch_8.gemfile.lock +++ b/gemfiles/ruby_2.6_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_graphql_1.12.gemfile.lock b/gemfiles/ruby_2.6_graphql_1.12.gemfile.lock index 6567e0bd0de..fd296d38472 100644 --- a/gemfiles/ruby_2.6_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_2.6_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_graphql_1.13.gemfile.lock b/gemfiles/ruby_2.6_graphql_1.13.gemfile.lock index 04161c34449..ca345789f1d 100644 --- a/gemfiles/ruby_2.6_graphql_1.13.gemfile.lock +++ b/gemfiles/ruby_2.6_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_graphql_2.0.gemfile.lock b/gemfiles/ruby_2.6_graphql_2.0.gemfile.lock index 634a962de05..aba0b434270 100644 --- a/gemfiles/ruby_2.6_graphql_2.0.gemfile.lock +++ b/gemfiles/ruby_2.6_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_hanami_1.gemfile.lock b/gemfiles/ruby_2.6_hanami_1.gemfile.lock index 47ace508423..3bcf9f9e806 100644 --- a/gemfiles/ruby_2.6_hanami_1.gemfile.lock +++ b/gemfiles/ruby_2.6_hanami_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_http.gemfile.lock b/gemfiles/ruby_2.6_http.gemfile.lock index 692646dc810..8bed5411824 100644 --- a/gemfiles/ruby_2.6_http.gemfile.lock +++ b/gemfiles/ruby_2.6_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_multi_rack_app.gemfile.lock b/gemfiles/ruby_2.6_multi_rack_app.gemfile.lock index f081442e2f0..5551e81e6dd 100644 --- a/gemfiles/ruby_2.6_multi_rack_app.gemfile.lock +++ b/gemfiles/ruby_2.6_multi_rack_app.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_opensearch_2.gemfile.lock b/gemfiles/ruby_2.6_opensearch_2.gemfile.lock index 3db88a751d7..ab1714984d5 100644 --- a/gemfiles/ruby_2.6_opensearch_2.gemfile.lock +++ b/gemfiles/ruby_2.6_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_opensearch_3.gemfile.lock b/gemfiles/ruby_2.6_opensearch_3.gemfile.lock index 6768ae02b0c..c298b080bac 100644 --- a/gemfiles/ruby_2.6_opensearch_3.gemfile.lock +++ b/gemfiles/ruby_2.6_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_opentelemetry.gemfile.lock b/gemfiles/ruby_2.6_opentelemetry.gemfile.lock index 3caec9f5870..3224ee62dd7 100755 --- a/gemfiles/ruby_2.6_opentelemetry.gemfile.lock +++ b/gemfiles/ruby_2.6_opentelemetry.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_opentracing.gemfile.lock b/gemfiles/ruby_2.6_opentracing.gemfile.lock index 535bc17210e..bd12bd1cd67 100644 --- a/gemfiles/ruby_2.6_opentracing.gemfile.lock +++ b/gemfiles/ruby_2.6_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rack_1.gemfile.lock b/gemfiles/ruby_2.6_rack_1.gemfile.lock index b9c1cfa27ad..c5dfba00e28 100644 --- a/gemfiles/ruby_2.6_rack_1.gemfile.lock +++ b/gemfiles/ruby_2.6_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rack_2.gemfile.lock b/gemfiles/ruby_2.6_rack_2.gemfile.lock index 5a8d8a2f6db..32b170bc8c2 100644 --- a/gemfiles/ruby_2.6_rack_2.gemfile.lock +++ b/gemfiles/ruby_2.6_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rack_3.gemfile.lock b/gemfiles/ruby_2.6_rack_3.gemfile.lock index b077129aad2..58aaa17dd27 100644 --- a/gemfiles/ruby_2.6_rack_3.gemfile.lock +++ b/gemfiles/ruby_2.6_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails5_mysql2.gemfile.lock b/gemfiles/ruby_2.6_rails5_mysql2.gemfile.lock index f298ef073a3..aa6f5c9e951 100644 --- a/gemfiles/ruby_2.6_rails5_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.6_rails5_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails5_postgres.gemfile.lock b/gemfiles/ruby_2.6_rails5_postgres.gemfile.lock index d4450ec96b4..28615ca74a5 100644 --- a/gemfiles/ruby_2.6_rails5_postgres.gemfile.lock +++ b/gemfiles/ruby_2.6_rails5_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails5_postgres_redis.gemfile.lock b/gemfiles/ruby_2.6_rails5_postgres_redis.gemfile.lock index e24263c71d9..2401bb57a6e 100644 --- a/gemfiles/ruby_2.6_rails5_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.6_rails5_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails5_postgres_redis_activesupport.gemfile.lock b/gemfiles/ruby_2.6_rails5_postgres_redis_activesupport.gemfile.lock index d2881b53394..88059ab79e5 100644 --- a/gemfiles/ruby_2.6_rails5_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.6_rails5_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails5_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.6_rails5_postgres_sidekiq.gemfile.lock index 183da8ec03b..b8e327e356e 100644 --- a/gemfiles/ruby_2.6_rails5_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.6_rails5_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails5_semantic_logger.gemfile.lock b/gemfiles/ruby_2.6_rails5_semantic_logger.gemfile.lock index 399e94cc0fb..021c0a287ef 100644 --- a/gemfiles/ruby_2.6_rails5_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.6_rails5_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails61_mysql2.gemfile.lock b/gemfiles/ruby_2.6_rails61_mysql2.gemfile.lock index 0a735552c9a..e90c3212090 100644 --- a/gemfiles/ruby_2.6_rails61_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.6_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails61_postgres.gemfile.lock b/gemfiles/ruby_2.6_rails61_postgres.gemfile.lock index 04f9d2ffeb1..a349e8d6d8f 100644 --- a/gemfiles/ruby_2.6_rails61_postgres.gemfile.lock +++ b/gemfiles/ruby_2.6_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails61_postgres_redis.gemfile.lock b/gemfiles/ruby_2.6_rails61_postgres_redis.gemfile.lock index e7cdb34fd9a..453859e4e81 100644 --- a/gemfiles/ruby_2.6_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.6_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.6_rails61_postgres_sidekiq.gemfile.lock index abb6093532e..1a8fcfccf4f 100644 --- a/gemfiles/ruby_2.6_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.6_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails61_semantic_logger.gemfile.lock b/gemfiles/ruby_2.6_rails61_semantic_logger.gemfile.lock index 674397227ee..0b42ed7485f 100644 --- a/gemfiles/ruby_2.6_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.6_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails6_mysql2.gemfile.lock b/gemfiles/ruby_2.6_rails6_mysql2.gemfile.lock index 33a486ebd5d..ee1b1ea0501 100644 --- a/gemfiles/ruby_2.6_rails6_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.6_rails6_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails6_postgres.gemfile.lock b/gemfiles/ruby_2.6_rails6_postgres.gemfile.lock index 6981997867f..5d75bda26de 100644 --- a/gemfiles/ruby_2.6_rails6_postgres.gemfile.lock +++ b/gemfiles/ruby_2.6_rails6_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails6_postgres_redis.gemfile.lock b/gemfiles/ruby_2.6_rails6_postgres_redis.gemfile.lock index c5f48686a99..852415e9f1a 100644 --- a/gemfiles/ruby_2.6_rails6_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.6_rails6_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails6_postgres_redis_activesupport.gemfile.lock b/gemfiles/ruby_2.6_rails6_postgres_redis_activesupport.gemfile.lock index e41d02d58a3..491717073f9 100644 --- a/gemfiles/ruby_2.6_rails6_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.6_rails6_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails6_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.6_rails6_postgres_sidekiq.gemfile.lock index 1c0c9eb64b9..cf383ce3b9d 100644 --- a/gemfiles/ruby_2.6_rails6_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.6_rails6_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_rails6_semantic_logger.gemfile.lock b/gemfiles/ruby_2.6_rails6_semantic_logger.gemfile.lock index 2a608b1c864..460bb048715 100644 --- a/gemfiles/ruby_2.6_rails6_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.6_rails6_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_redis_3.gemfile.lock b/gemfiles/ruby_2.6_redis_3.gemfile.lock index f370bd6dbde..eaffe42b68e 100644 --- a/gemfiles/ruby_2.6_redis_3.gemfile.lock +++ b/gemfiles/ruby_2.6_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_redis_4.gemfile.lock b/gemfiles/ruby_2.6_redis_4.gemfile.lock index 4300a242147..247032d7cbc 100644 --- a/gemfiles/ruby_2.6_redis_4.gemfile.lock +++ b/gemfiles/ruby_2.6_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_redis_5.gemfile.lock b/gemfiles/ruby_2.6_redis_5.gemfile.lock index 1764113972a..3f1dfcc4a15 100644 --- a/gemfiles/ruby_2.6_redis_5.gemfile.lock +++ b/gemfiles/ruby_2.6_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_relational_db.gemfile.lock b/gemfiles/ruby_2.6_relational_db.gemfile.lock index 2be5ea411c5..365059770a8 100644 --- a/gemfiles/ruby_2.6_relational_db.gemfile.lock +++ b/gemfiles/ruby_2.6_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_resque2_redis3.gemfile.lock b/gemfiles/ruby_2.6_resque2_redis3.gemfile.lock index 9e2dab1f6ae..a6ff0cda019 100644 --- a/gemfiles/ruby_2.6_resque2_redis3.gemfile.lock +++ b/gemfiles/ruby_2.6_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_resque2_redis4.gemfile.lock b/gemfiles/ruby_2.6_resque2_redis4.gemfile.lock index 7d88e2a35d7..be091310ff4 100644 --- a/gemfiles/ruby_2.6_resque2_redis4.gemfile.lock +++ b/gemfiles/ruby_2.6_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.6_sinatra.gemfile.lock b/gemfiles/ruby_2.6_sinatra.gemfile.lock index cf4b9ee5f99..0e739dfd73e 100644 --- a/gemfiles/ruby_2.6_sinatra.gemfile.lock +++ b/gemfiles/ruby_2.6_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7.6_sinatra.gemfile.lock b/gemfiles/ruby_2.7.6_sinatra.gemfile.lock index 73db22b2b5f..bce3a7124e6 100644 --- a/gemfiles/ruby_2.7.6_sinatra.gemfile.lock +++ b/gemfiles/ruby_2.7.6_sinatra.gemfile.lock @@ -12,7 +12,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.2.0) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_activesupport.gemfile.lock b/gemfiles/ruby_2.7_activesupport.gemfile.lock index 91c4f1e938f..dac276b854e 100644 --- a/gemfiles/ruby_2.7_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.7_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_aws.gemfile.lock b/gemfiles/ruby_2.7_aws.gemfile.lock index bd949662509..8baba366256 100644 --- a/gemfiles/ruby_2.7_aws.gemfile.lock +++ b/gemfiles/ruby_2.7_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_contrib.gemfile.lock b/gemfiles/ruby_2.7_contrib.gemfile.lock index ea3b3df5afe..94d717b7fb8 100644 --- a/gemfiles/ruby_2.7_contrib.gemfile.lock +++ b/gemfiles/ruby_2.7_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_contrib_old.gemfile.lock b/gemfiles/ruby_2.7_contrib_old.gemfile.lock index c435e9a8f39..a4eb5ff08a0 100644 --- a/gemfiles/ruby_2.7_contrib_old.gemfile.lock +++ b/gemfiles/ruby_2.7_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_core_old.gemfile.lock b/gemfiles/ruby_2.7_core_old.gemfile.lock index 130fd3bea94..ab9475ac85c 100644 --- a/gemfiles/ruby_2.7_core_old.gemfile.lock +++ b/gemfiles/ruby_2.7_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_elasticsearch_7.gemfile.lock b/gemfiles/ruby_2.7_elasticsearch_7.gemfile.lock index 63f955efa2a..25f001708ba 100644 --- a/gemfiles/ruby_2.7_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_2.7_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_elasticsearch_8.gemfile.lock b/gemfiles/ruby_2.7_elasticsearch_8.gemfile.lock index b7e40e129e6..25b3eaebb51 100644 --- a/gemfiles/ruby_2.7_elasticsearch_8.gemfile.lock +++ b/gemfiles/ruby_2.7_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_graphql_1.12.gemfile.lock b/gemfiles/ruby_2.7_graphql_1.12.gemfile.lock index 0405f8fb8ad..1b13dbea2b1 100644 --- a/gemfiles/ruby_2.7_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_2.7_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_graphql_1.13.gemfile.lock b/gemfiles/ruby_2.7_graphql_1.13.gemfile.lock index 307ab2cce3a..aa64dc8d7cc 100644 --- a/gemfiles/ruby_2.7_graphql_1.13.gemfile.lock +++ b/gemfiles/ruby_2.7_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_graphql_2.0.gemfile.lock b/gemfiles/ruby_2.7_graphql_2.0.gemfile.lock index 73aad0b3a4f..808f0a7f752 100644 --- a/gemfiles/ruby_2.7_graphql_2.0.gemfile.lock +++ b/gemfiles/ruby_2.7_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_graphql_2.1.gemfile.lock b/gemfiles/ruby_2.7_graphql_2.1.gemfile.lock index eb0fd905d94..fe742625674 100644 --- a/gemfiles/ruby_2.7_graphql_2.1.gemfile.lock +++ b/gemfiles/ruby_2.7_graphql_2.1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_graphql_2.2.gemfile.lock b/gemfiles/ruby_2.7_graphql_2.2.gemfile.lock index e33c9074194..d3d78af69d0 100644 --- a/gemfiles/ruby_2.7_graphql_2.2.gemfile.lock +++ b/gemfiles/ruby_2.7_graphql_2.2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_hanami_1.gemfile.lock b/gemfiles/ruby_2.7_hanami_1.gemfile.lock index 0de1f8ecbca..b20e7439105 100644 --- a/gemfiles/ruby_2.7_hanami_1.gemfile.lock +++ b/gemfiles/ruby_2.7_hanami_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_http.gemfile.lock b/gemfiles/ruby_2.7_http.gemfile.lock index ef36949ffbd..2c9423c6bdf 100644 --- a/gemfiles/ruby_2.7_http.gemfile.lock +++ b/gemfiles/ruby_2.7_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_multi_rack_app.gemfile.lock b/gemfiles/ruby_2.7_multi_rack_app.gemfile.lock index bd11d91a852..22bdb78981c 100644 --- a/gemfiles/ruby_2.7_multi_rack_app.gemfile.lock +++ b/gemfiles/ruby_2.7_multi_rack_app.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_opensearch_2.gemfile.lock b/gemfiles/ruby_2.7_opensearch_2.gemfile.lock index b77e8ba13a4..e7b28ed9890 100644 --- a/gemfiles/ruby_2.7_opensearch_2.gemfile.lock +++ b/gemfiles/ruby_2.7_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_opensearch_3.gemfile.lock b/gemfiles/ruby_2.7_opensearch_3.gemfile.lock index 51bd8a6c745..1ee20ca696a 100644 --- a/gemfiles/ruby_2.7_opensearch_3.gemfile.lock +++ b/gemfiles/ruby_2.7_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_opentelemetry.gemfile.lock b/gemfiles/ruby_2.7_opentelemetry.gemfile.lock index c39e3b56f42..63695f11904 100755 --- a/gemfiles/ruby_2.7_opentelemetry.gemfile.lock +++ b/gemfiles/ruby_2.7_opentelemetry.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_opentracing.gemfile.lock b/gemfiles/ruby_2.7_opentracing.gemfile.lock index 90eaec400d8..e0d33d180b5 100644 --- a/gemfiles/ruby_2.7_opentracing.gemfile.lock +++ b/gemfiles/ruby_2.7_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rack_1.gemfile.lock b/gemfiles/ruby_2.7_rack_1.gemfile.lock index 4923f6d8ac5..532316fa70f 100644 --- a/gemfiles/ruby_2.7_rack_1.gemfile.lock +++ b/gemfiles/ruby_2.7_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rack_2.gemfile.lock b/gemfiles/ruby_2.7_rack_2.gemfile.lock index fe5f26013fa..4ac543f6d15 100644 --- a/gemfiles/ruby_2.7_rack_2.gemfile.lock +++ b/gemfiles/ruby_2.7_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rack_3.gemfile.lock b/gemfiles/ruby_2.7_rack_3.gemfile.lock index 2a5a972bd52..f1c56b6f325 100644 --- a/gemfiles/ruby_2.7_rack_3.gemfile.lock +++ b/gemfiles/ruby_2.7_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails5_mysql2.gemfile.lock b/gemfiles/ruby_2.7_rails5_mysql2.gemfile.lock index 597a4a350d5..a7459468a45 100644 --- a/gemfiles/ruby_2.7_rails5_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.7_rails5_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails5_postgres.gemfile.lock b/gemfiles/ruby_2.7_rails5_postgres.gemfile.lock index 00f34ce4ac4..9ee387d7192 100644 --- a/gemfiles/ruby_2.7_rails5_postgres.gemfile.lock +++ b/gemfiles/ruby_2.7_rails5_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails5_postgres_redis.gemfile.lock b/gemfiles/ruby_2.7_rails5_postgres_redis.gemfile.lock index a23d6178e08..31160a38c12 100644 --- a/gemfiles/ruby_2.7_rails5_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.7_rails5_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails5_postgres_redis_activesupport.gemfile.lock b/gemfiles/ruby_2.7_rails5_postgres_redis_activesupport.gemfile.lock index bc82855b96d..a00e02cacea 100644 --- a/gemfiles/ruby_2.7_rails5_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.7_rails5_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails5_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.7_rails5_postgres_sidekiq.gemfile.lock index 739e90da99d..6f459fe99cf 100644 --- a/gemfiles/ruby_2.7_rails5_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.7_rails5_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails5_semantic_logger.gemfile.lock b/gemfiles/ruby_2.7_rails5_semantic_logger.gemfile.lock index 2f5a93bd18c..86418125d49 100644 --- a/gemfiles/ruby_2.7_rails5_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.7_rails5_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails61_mysql2.gemfile.lock b/gemfiles/ruby_2.7_rails61_mysql2.gemfile.lock index 41313f3dda8..0c7a17506ba 100644 --- a/gemfiles/ruby_2.7_rails61_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.7_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails61_postgres.gemfile.lock b/gemfiles/ruby_2.7_rails61_postgres.gemfile.lock index 3074b6e4f50..0c3048222a6 100644 --- a/gemfiles/ruby_2.7_rails61_postgres.gemfile.lock +++ b/gemfiles/ruby_2.7_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails61_postgres_redis.gemfile.lock b/gemfiles/ruby_2.7_rails61_postgres_redis.gemfile.lock index 32d50d26713..08f7d101901 100644 --- a/gemfiles/ruby_2.7_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.7_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.7_rails61_postgres_sidekiq.gemfile.lock index e240d4d58c6..7c3d21ef1bb 100644 --- a/gemfiles/ruby_2.7_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.7_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails61_semantic_logger.gemfile.lock b/gemfiles/ruby_2.7_rails61_semantic_logger.gemfile.lock index 3d5e4184c73..32269c4deaf 100644 --- a/gemfiles/ruby_2.7_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.7_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails6_mysql2.gemfile.lock b/gemfiles/ruby_2.7_rails6_mysql2.gemfile.lock index 1297a5cb59d..e716032458f 100644 --- a/gemfiles/ruby_2.7_rails6_mysql2.gemfile.lock +++ b/gemfiles/ruby_2.7_rails6_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails6_postgres.gemfile.lock b/gemfiles/ruby_2.7_rails6_postgres.gemfile.lock index d2b335e26ef..025535015c7 100644 --- a/gemfiles/ruby_2.7_rails6_postgres.gemfile.lock +++ b/gemfiles/ruby_2.7_rails6_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails6_postgres_redis.gemfile.lock b/gemfiles/ruby_2.7_rails6_postgres_redis.gemfile.lock index 0fb4755e8d1..1fff71a8c07 100644 --- a/gemfiles/ruby_2.7_rails6_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_2.7_rails6_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails6_postgres_redis_activesupport.gemfile.lock b/gemfiles/ruby_2.7_rails6_postgres_redis_activesupport.gemfile.lock index d45a2f64864..c9fd9e93168 100644 --- a/gemfiles/ruby_2.7_rails6_postgres_redis_activesupport.gemfile.lock +++ b/gemfiles/ruby_2.7_rails6_postgres_redis_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails6_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_2.7_rails6_postgres_sidekiq.gemfile.lock index 0a8f09885fc..7f4ac18dfc0 100644 --- a/gemfiles/ruby_2.7_rails6_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_2.7_rails6_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_rails6_semantic_logger.gemfile.lock b/gemfiles/ruby_2.7_rails6_semantic_logger.gemfile.lock index bcc7846dee5..25be7f86a5a 100644 --- a/gemfiles/ruby_2.7_rails6_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_2.7_rails6_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_redis_3.gemfile.lock b/gemfiles/ruby_2.7_redis_3.gemfile.lock index b886259cb6f..92324d8a407 100644 --- a/gemfiles/ruby_2.7_redis_3.gemfile.lock +++ b/gemfiles/ruby_2.7_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_redis_4.gemfile.lock b/gemfiles/ruby_2.7_redis_4.gemfile.lock index 3747191dad2..0130c86d2a9 100644 --- a/gemfiles/ruby_2.7_redis_4.gemfile.lock +++ b/gemfiles/ruby_2.7_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_redis_5.gemfile.lock b/gemfiles/ruby_2.7_redis_5.gemfile.lock index 9ba721d40d5..56ef878e305 100644 --- a/gemfiles/ruby_2.7_redis_5.gemfile.lock +++ b/gemfiles/ruby_2.7_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_relational_db.gemfile.lock b/gemfiles/ruby_2.7_relational_db.gemfile.lock index c67ff44e972..7f9e70e07f3 100644 --- a/gemfiles/ruby_2.7_relational_db.gemfile.lock +++ b/gemfiles/ruby_2.7_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_resque2_redis3.gemfile.lock b/gemfiles/ruby_2.7_resque2_redis3.gemfile.lock index 94920c912ef..13f6b25c7fb 100644 --- a/gemfiles/ruby_2.7_resque2_redis3.gemfile.lock +++ b/gemfiles/ruby_2.7_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_resque2_redis4.gemfile.lock b/gemfiles/ruby_2.7_resque2_redis4.gemfile.lock index 708af36d9fc..a4a79da5b68 100644 --- a/gemfiles/ruby_2.7_resque2_redis4.gemfile.lock +++ b/gemfiles/ruby_2.7_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_2.7_sinatra.gemfile.lock b/gemfiles/ruby_2.7_sinatra.gemfile.lock index 63b339f9b5a..f18226bef33 100644 --- a/gemfiles/ruby_2.7_sinatra.gemfile.lock +++ b/gemfiles/ruby_2.7_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_activesupport.gemfile.lock b/gemfiles/ruby_3.0_activesupport.gemfile.lock index 60d725e86e6..c362183ccc6 100644 --- a/gemfiles/ruby_3.0_activesupport.gemfile.lock +++ b/gemfiles/ruby_3.0_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_aws.gemfile.lock b/gemfiles/ruby_3.0_aws.gemfile.lock index b0017009c01..d96bfca4d9b 100644 --- a/gemfiles/ruby_3.0_aws.gemfile.lock +++ b/gemfiles/ruby_3.0_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_contrib.gemfile.lock b/gemfiles/ruby_3.0_contrib.gemfile.lock index a44f6141e06..a12b6e4827c 100644 --- a/gemfiles/ruby_3.0_contrib.gemfile.lock +++ b/gemfiles/ruby_3.0_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_contrib_old.gemfile.lock b/gemfiles/ruby_3.0_contrib_old.gemfile.lock index f7a80d0773e..0aae2515604 100644 --- a/gemfiles/ruby_3.0_contrib_old.gemfile.lock +++ b/gemfiles/ruby_3.0_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_core_old.gemfile.lock b/gemfiles/ruby_3.0_core_old.gemfile.lock index 3eb9b1a555f..8eb05f0f611 100644 --- a/gemfiles/ruby_3.0_core_old.gemfile.lock +++ b/gemfiles/ruby_3.0_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_elasticsearch_7.gemfile.lock b/gemfiles/ruby_3.0_elasticsearch_7.gemfile.lock index 40fc1311c2f..e085b44c55c 100644 --- a/gemfiles/ruby_3.0_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_3.0_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_elasticsearch_8.gemfile.lock b/gemfiles/ruby_3.0_elasticsearch_8.gemfile.lock index 1bcc9e22262..c1c898c5c22 100644 --- a/gemfiles/ruby_3.0_elasticsearch_8.gemfile.lock +++ b/gemfiles/ruby_3.0_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_graphql_1.12.gemfile.lock b/gemfiles/ruby_3.0_graphql_1.12.gemfile.lock index aa3832e6211..d117660c16e 100644 --- a/gemfiles/ruby_3.0_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_3.0_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_graphql_1.13.gemfile.lock b/gemfiles/ruby_3.0_graphql_1.13.gemfile.lock index 3f5583d33f6..578526e9126 100644 --- a/gemfiles/ruby_3.0_graphql_1.13.gemfile.lock +++ b/gemfiles/ruby_3.0_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_graphql_2.0.gemfile.lock b/gemfiles/ruby_3.0_graphql_2.0.gemfile.lock index 83d92f1b26e..d9c69785d59 100644 --- a/gemfiles/ruby_3.0_graphql_2.0.gemfile.lock +++ b/gemfiles/ruby_3.0_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_graphql_2.1.gemfile.lock b/gemfiles/ruby_3.0_graphql_2.1.gemfile.lock index 562d1666b8b..c3134eee8ad 100644 --- a/gemfiles/ruby_3.0_graphql_2.1.gemfile.lock +++ b/gemfiles/ruby_3.0_graphql_2.1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_graphql_2.2.gemfile.lock b/gemfiles/ruby_3.0_graphql_2.2.gemfile.lock index 2aebb6558de..019c3cef931 100644 --- a/gemfiles/ruby_3.0_graphql_2.2.gemfile.lock +++ b/gemfiles/ruby_3.0_graphql_2.2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_http.gemfile.lock b/gemfiles/ruby_3.0_http.gemfile.lock index 0828c0675e0..f18be37402d 100644 --- a/gemfiles/ruby_3.0_http.gemfile.lock +++ b/gemfiles/ruby_3.0_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_multi_rack_app.gemfile.lock b/gemfiles/ruby_3.0_multi_rack_app.gemfile.lock index c978c49a3ee..bb659c71d4a 100644 --- a/gemfiles/ruby_3.0_multi_rack_app.gemfile.lock +++ b/gemfiles/ruby_3.0_multi_rack_app.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_opensearch_2.gemfile.lock b/gemfiles/ruby_3.0_opensearch_2.gemfile.lock index 6870266491e..aa91a1f3011 100644 --- a/gemfiles/ruby_3.0_opensearch_2.gemfile.lock +++ b/gemfiles/ruby_3.0_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_opensearch_3.gemfile.lock b/gemfiles/ruby_3.0_opensearch_3.gemfile.lock index 7cb3056c97d..5a6361674ac 100644 --- a/gemfiles/ruby_3.0_opensearch_3.gemfile.lock +++ b/gemfiles/ruby_3.0_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_opentelemetry.gemfile.lock b/gemfiles/ruby_3.0_opentelemetry.gemfile.lock index 5c8b9ed115f..470ebc382f0 100755 --- a/gemfiles/ruby_3.0_opentelemetry.gemfile.lock +++ b/gemfiles/ruby_3.0_opentelemetry.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_opentracing.gemfile.lock b/gemfiles/ruby_3.0_opentracing.gemfile.lock index 4587e37d1da..82a900936d1 100644 --- a/gemfiles/ruby_3.0_opentracing.gemfile.lock +++ b/gemfiles/ruby_3.0_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_rack_1.gemfile.lock b/gemfiles/ruby_3.0_rack_1.gemfile.lock index 7776bc957f0..210ea63fb35 100644 --- a/gemfiles/ruby_3.0_rack_1.gemfile.lock +++ b/gemfiles/ruby_3.0_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_rack_2.gemfile.lock b/gemfiles/ruby_3.0_rack_2.gemfile.lock index 82706294b69..c073d8ea053 100644 --- a/gemfiles/ruby_3.0_rack_2.gemfile.lock +++ b/gemfiles/ruby_3.0_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_rack_3.gemfile.lock b/gemfiles/ruby_3.0_rack_3.gemfile.lock index c1dde9470bf..b8899228730 100644 --- a/gemfiles/ruby_3.0_rack_3.gemfile.lock +++ b/gemfiles/ruby_3.0_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_rails61_mysql2.gemfile.lock b/gemfiles/ruby_3.0_rails61_mysql2.gemfile.lock index a73e88a9ff0..d1cdf445c55 100644 --- a/gemfiles/ruby_3.0_rails61_mysql2.gemfile.lock +++ b/gemfiles/ruby_3.0_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_rails61_postgres.gemfile.lock b/gemfiles/ruby_3.0_rails61_postgres.gemfile.lock index f8cb290477e..d84595db402 100644 --- a/gemfiles/ruby_3.0_rails61_postgres.gemfile.lock +++ b/gemfiles/ruby_3.0_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_rails61_postgres_redis.gemfile.lock b/gemfiles/ruby_3.0_rails61_postgres_redis.gemfile.lock index 1779b80c212..2bcc5bbd0dc 100644 --- a/gemfiles/ruby_3.0_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_3.0_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_3.0_rails61_postgres_sidekiq.gemfile.lock index bc770c27c19..a0e187bd2b6 100644 --- a/gemfiles/ruby_3.0_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_3.0_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_rails61_semantic_logger.gemfile.lock b/gemfiles/ruby_3.0_rails61_semantic_logger.gemfile.lock index 190c42344f4..7b79e60a94c 100644 --- a/gemfiles/ruby_3.0_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_3.0_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_rails61_trilogy.gemfile.lock b/gemfiles/ruby_3.0_rails61_trilogy.gemfile.lock index 86a0d356dfd..d7cfa844280 100644 --- a/gemfiles/ruby_3.0_rails61_trilogy.gemfile.lock +++ b/gemfiles/ruby_3.0_rails61_trilogy.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_redis_3.gemfile.lock b/gemfiles/ruby_3.0_redis_3.gemfile.lock index 358c165f704..b4af0d7b979 100644 --- a/gemfiles/ruby_3.0_redis_3.gemfile.lock +++ b/gemfiles/ruby_3.0_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_redis_4.gemfile.lock b/gemfiles/ruby_3.0_redis_4.gemfile.lock index 0dfe6e45218..d25392f5c58 100644 --- a/gemfiles/ruby_3.0_redis_4.gemfile.lock +++ b/gemfiles/ruby_3.0_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_redis_5.gemfile.lock b/gemfiles/ruby_3.0_redis_5.gemfile.lock index 3613667bb10..f094441d55b 100644 --- a/gemfiles/ruby_3.0_redis_5.gemfile.lock +++ b/gemfiles/ruby_3.0_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_relational_db.gemfile.lock b/gemfiles/ruby_3.0_relational_db.gemfile.lock index 72cc81df80d..2f44f76bccc 100644 --- a/gemfiles/ruby_3.0_relational_db.gemfile.lock +++ b/gemfiles/ruby_3.0_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_resque2_redis3.gemfile.lock b/gemfiles/ruby_3.0_resque2_redis3.gemfile.lock index 3a6363453eb..efe910c403b 100644 --- a/gemfiles/ruby_3.0_resque2_redis3.gemfile.lock +++ b/gemfiles/ruby_3.0_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_resque2_redis4.gemfile.lock b/gemfiles/ruby_3.0_resque2_redis4.gemfile.lock index 726140c82e1..d3dbeba4b51 100644 --- a/gemfiles/ruby_3.0_resque2_redis4.gemfile.lock +++ b/gemfiles/ruby_3.0_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.0_sinatra.gemfile.lock b/gemfiles/ruby_3.0_sinatra.gemfile.lock index 0435fa26eca..72d8d4731c2 100644 --- a/gemfiles/ruby_3.0_sinatra.gemfile.lock +++ b/gemfiles/ruby_3.0_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_activesupport.gemfile.lock b/gemfiles/ruby_3.1_activesupport.gemfile.lock index 60d725e86e6..c362183ccc6 100644 --- a/gemfiles/ruby_3.1_activesupport.gemfile.lock +++ b/gemfiles/ruby_3.1_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_aws.gemfile.lock b/gemfiles/ruby_3.1_aws.gemfile.lock index b0017009c01..d96bfca4d9b 100644 --- a/gemfiles/ruby_3.1_aws.gemfile.lock +++ b/gemfiles/ruby_3.1_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_contrib.gemfile.lock b/gemfiles/ruby_3.1_contrib.gemfile.lock index a44f6141e06..a12b6e4827c 100644 --- a/gemfiles/ruby_3.1_contrib.gemfile.lock +++ b/gemfiles/ruby_3.1_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_contrib_old.gemfile.lock b/gemfiles/ruby_3.1_contrib_old.gemfile.lock index f7a80d0773e..0aae2515604 100644 --- a/gemfiles/ruby_3.1_contrib_old.gemfile.lock +++ b/gemfiles/ruby_3.1_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_core_old.gemfile.lock b/gemfiles/ruby_3.1_core_old.gemfile.lock index 3eb9b1a555f..8eb05f0f611 100644 --- a/gemfiles/ruby_3.1_core_old.gemfile.lock +++ b/gemfiles/ruby_3.1_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_elasticsearch_7.gemfile.lock b/gemfiles/ruby_3.1_elasticsearch_7.gemfile.lock index 40fc1311c2f..e085b44c55c 100644 --- a/gemfiles/ruby_3.1_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_3.1_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_elasticsearch_8.gemfile.lock b/gemfiles/ruby_3.1_elasticsearch_8.gemfile.lock index 1bcc9e22262..c1c898c5c22 100644 --- a/gemfiles/ruby_3.1_elasticsearch_8.gemfile.lock +++ b/gemfiles/ruby_3.1_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_graphql_1.12.gemfile.lock b/gemfiles/ruby_3.1_graphql_1.12.gemfile.lock index aa3832e6211..d117660c16e 100644 --- a/gemfiles/ruby_3.1_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_3.1_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_graphql_1.13.gemfile.lock b/gemfiles/ruby_3.1_graphql_1.13.gemfile.lock index 3f5583d33f6..578526e9126 100644 --- a/gemfiles/ruby_3.1_graphql_1.13.gemfile.lock +++ b/gemfiles/ruby_3.1_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_graphql_2.0.gemfile.lock b/gemfiles/ruby_3.1_graphql_2.0.gemfile.lock index 83d92f1b26e..d9c69785d59 100644 --- a/gemfiles/ruby_3.1_graphql_2.0.gemfile.lock +++ b/gemfiles/ruby_3.1_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_graphql_2.1.gemfile.lock b/gemfiles/ruby_3.1_graphql_2.1.gemfile.lock index 562d1666b8b..c3134eee8ad 100644 --- a/gemfiles/ruby_3.1_graphql_2.1.gemfile.lock +++ b/gemfiles/ruby_3.1_graphql_2.1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_graphql_2.2.gemfile.lock b/gemfiles/ruby_3.1_graphql_2.2.gemfile.lock index 2aebb6558de..019c3cef931 100644 --- a/gemfiles/ruby_3.1_graphql_2.2.gemfile.lock +++ b/gemfiles/ruby_3.1_graphql_2.2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_http.gemfile.lock b/gemfiles/ruby_3.1_http.gemfile.lock index 0828c0675e0..f18be37402d 100644 --- a/gemfiles/ruby_3.1_http.gemfile.lock +++ b/gemfiles/ruby_3.1_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_opensearch_2.gemfile.lock b/gemfiles/ruby_3.1_opensearch_2.gemfile.lock index 6870266491e..aa91a1f3011 100644 --- a/gemfiles/ruby_3.1_opensearch_2.gemfile.lock +++ b/gemfiles/ruby_3.1_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_opensearch_3.gemfile.lock b/gemfiles/ruby_3.1_opensearch_3.gemfile.lock index 7cb3056c97d..5a6361674ac 100644 --- a/gemfiles/ruby_3.1_opensearch_3.gemfile.lock +++ b/gemfiles/ruby_3.1_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_opentelemetry.gemfile.lock b/gemfiles/ruby_3.1_opentelemetry.gemfile.lock index 826fbd47dca..90edf634e3a 100644 --- a/gemfiles/ruby_3.1_opentelemetry.gemfile.lock +++ b/gemfiles/ruby_3.1_opentelemetry.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_opentracing.gemfile.lock b/gemfiles/ruby_3.1_opentracing.gemfile.lock index 4587e37d1da..82a900936d1 100644 --- a/gemfiles/ruby_3.1_opentracing.gemfile.lock +++ b/gemfiles/ruby_3.1_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_rack_1.gemfile.lock b/gemfiles/ruby_3.1_rack_1.gemfile.lock index 7776bc957f0..210ea63fb35 100644 --- a/gemfiles/ruby_3.1_rack_1.gemfile.lock +++ b/gemfiles/ruby_3.1_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_rack_2.gemfile.lock b/gemfiles/ruby_3.1_rack_2.gemfile.lock index 82706294b69..c073d8ea053 100644 --- a/gemfiles/ruby_3.1_rack_2.gemfile.lock +++ b/gemfiles/ruby_3.1_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_rack_3.gemfile.lock b/gemfiles/ruby_3.1_rack_3.gemfile.lock index c1dde9470bf..b8899228730 100644 --- a/gemfiles/ruby_3.1_rack_3.gemfile.lock +++ b/gemfiles/ruby_3.1_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_rails61_mysql2.gemfile.lock b/gemfiles/ruby_3.1_rails61_mysql2.gemfile.lock index a73e88a9ff0..d1cdf445c55 100644 --- a/gemfiles/ruby_3.1_rails61_mysql2.gemfile.lock +++ b/gemfiles/ruby_3.1_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_rails61_postgres.gemfile.lock b/gemfiles/ruby_3.1_rails61_postgres.gemfile.lock index f8cb290477e..d84595db402 100644 --- a/gemfiles/ruby_3.1_rails61_postgres.gemfile.lock +++ b/gemfiles/ruby_3.1_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_rails61_postgres_redis.gemfile.lock b/gemfiles/ruby_3.1_rails61_postgres_redis.gemfile.lock index 1779b80c212..2bcc5bbd0dc 100644 --- a/gemfiles/ruby_3.1_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_3.1_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_3.1_rails61_postgres_sidekiq.gemfile.lock index bc770c27c19..a0e187bd2b6 100644 --- a/gemfiles/ruby_3.1_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_3.1_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_rails61_semantic_logger.gemfile.lock b/gemfiles/ruby_3.1_rails61_semantic_logger.gemfile.lock index 190c42344f4..7b79e60a94c 100644 --- a/gemfiles/ruby_3.1_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_3.1_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_rails61_trilogy.gemfile.lock b/gemfiles/ruby_3.1_rails61_trilogy.gemfile.lock index 86a0d356dfd..d7cfa844280 100644 --- a/gemfiles/ruby_3.1_rails61_trilogy.gemfile.lock +++ b/gemfiles/ruby_3.1_rails61_trilogy.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_redis_3.gemfile.lock b/gemfiles/ruby_3.1_redis_3.gemfile.lock index 358c165f704..b4af0d7b979 100644 --- a/gemfiles/ruby_3.1_redis_3.gemfile.lock +++ b/gemfiles/ruby_3.1_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_redis_4.gemfile.lock b/gemfiles/ruby_3.1_redis_4.gemfile.lock index 0dfe6e45218..d25392f5c58 100644 --- a/gemfiles/ruby_3.1_redis_4.gemfile.lock +++ b/gemfiles/ruby_3.1_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_redis_5.gemfile.lock b/gemfiles/ruby_3.1_redis_5.gemfile.lock index 3613667bb10..f094441d55b 100644 --- a/gemfiles/ruby_3.1_redis_5.gemfile.lock +++ b/gemfiles/ruby_3.1_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_relational_db.gemfile.lock b/gemfiles/ruby_3.1_relational_db.gemfile.lock index 72cc81df80d..2f44f76bccc 100644 --- a/gemfiles/ruby_3.1_relational_db.gemfile.lock +++ b/gemfiles/ruby_3.1_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_resque2_redis3.gemfile.lock b/gemfiles/ruby_3.1_resque2_redis3.gemfile.lock index 3a6363453eb..efe910c403b 100644 --- a/gemfiles/ruby_3.1_resque2_redis3.gemfile.lock +++ b/gemfiles/ruby_3.1_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_resque2_redis4.gemfile.lock b/gemfiles/ruby_3.1_resque2_redis4.gemfile.lock index 726140c82e1..d3dbeba4b51 100644 --- a/gemfiles/ruby_3.1_resque2_redis4.gemfile.lock +++ b/gemfiles/ruby_3.1_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.1_sinatra.gemfile.lock b/gemfiles/ruby_3.1_sinatra.gemfile.lock index 0435fa26eca..72d8d4731c2 100644 --- a/gemfiles/ruby_3.1_sinatra.gemfile.lock +++ b/gemfiles/ruby_3.1_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_activesupport.gemfile.lock b/gemfiles/ruby_3.2_activesupport.gemfile.lock index 7913e7b3d2e..4d3c1253782 100644 --- a/gemfiles/ruby_3.2_activesupport.gemfile.lock +++ b/gemfiles/ruby_3.2_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_aws.gemfile.lock b/gemfiles/ruby_3.2_aws.gemfile.lock index 104236ed022..78239073b70 100644 --- a/gemfiles/ruby_3.2_aws.gemfile.lock +++ b/gemfiles/ruby_3.2_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_contrib.gemfile.lock b/gemfiles/ruby_3.2_contrib.gemfile.lock index dca4e7b8148..cc9c3e5194a 100644 --- a/gemfiles/ruby_3.2_contrib.gemfile.lock +++ b/gemfiles/ruby_3.2_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_contrib_old.gemfile.lock b/gemfiles/ruby_3.2_contrib_old.gemfile.lock index 569b537039d..5ed7adf3aaf 100644 --- a/gemfiles/ruby_3.2_contrib_old.gemfile.lock +++ b/gemfiles/ruby_3.2_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_core_old.gemfile.lock b/gemfiles/ruby_3.2_core_old.gemfile.lock index 5103e9cd989..1bab7eba25c 100644 --- a/gemfiles/ruby_3.2_core_old.gemfile.lock +++ b/gemfiles/ruby_3.2_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_elasticsearch_7.gemfile.lock b/gemfiles/ruby_3.2_elasticsearch_7.gemfile.lock index c8c9cea5c80..1fac3523c88 100644 --- a/gemfiles/ruby_3.2_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_3.2_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_elasticsearch_8.gemfile.lock b/gemfiles/ruby_3.2_elasticsearch_8.gemfile.lock index c0f3951b375..a557d6db5ad 100644 --- a/gemfiles/ruby_3.2_elasticsearch_8.gemfile.lock +++ b/gemfiles/ruby_3.2_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_graphql_1.12.gemfile.lock b/gemfiles/ruby_3.2_graphql_1.12.gemfile.lock index 82921314392..f7f8def566c 100644 --- a/gemfiles/ruby_3.2_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_3.2_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_graphql_1.13.gemfile.lock b/gemfiles/ruby_3.2_graphql_1.13.gemfile.lock index 9882448362d..577eb9fb3ec 100644 --- a/gemfiles/ruby_3.2_graphql_1.13.gemfile.lock +++ b/gemfiles/ruby_3.2_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_graphql_2.0.gemfile.lock b/gemfiles/ruby_3.2_graphql_2.0.gemfile.lock index c25c653e146..1174dc42963 100644 --- a/gemfiles/ruby_3.2_graphql_2.0.gemfile.lock +++ b/gemfiles/ruby_3.2_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_graphql_2.1.gemfile.lock b/gemfiles/ruby_3.2_graphql_2.1.gemfile.lock index 35179e4cbaf..812b011e726 100644 --- a/gemfiles/ruby_3.2_graphql_2.1.gemfile.lock +++ b/gemfiles/ruby_3.2_graphql_2.1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_graphql_2.2.gemfile.lock b/gemfiles/ruby_3.2_graphql_2.2.gemfile.lock index 9d999dc5d9e..dc6473c85af 100644 --- a/gemfiles/ruby_3.2_graphql_2.2.gemfile.lock +++ b/gemfiles/ruby_3.2_graphql_2.2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_http.gemfile.lock b/gemfiles/ruby_3.2_http.gemfile.lock index 5ebe597dfd7..7c0ef3386ce 100644 --- a/gemfiles/ruby_3.2_http.gemfile.lock +++ b/gemfiles/ruby_3.2_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_multi_rack_app.gemfile.lock b/gemfiles/ruby_3.2_multi_rack_app.gemfile.lock index d56093e7067..7c8334b3149 100644 --- a/gemfiles/ruby_3.2_multi_rack_app.gemfile.lock +++ b/gemfiles/ruby_3.2_multi_rack_app.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_opensearch_2.gemfile.lock b/gemfiles/ruby_3.2_opensearch_2.gemfile.lock index d85d426e6de..bd4077959db 100644 --- a/gemfiles/ruby_3.2_opensearch_2.gemfile.lock +++ b/gemfiles/ruby_3.2_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_opensearch_3.gemfile.lock b/gemfiles/ruby_3.2_opensearch_3.gemfile.lock index 4d77fa3c909..57a507f5805 100644 --- a/gemfiles/ruby_3.2_opensearch_3.gemfile.lock +++ b/gemfiles/ruby_3.2_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_opentelemetry.gemfile.lock b/gemfiles/ruby_3.2_opentelemetry.gemfile.lock index 5b7a063f26f..3ca2b0d6ca7 100644 --- a/gemfiles/ruby_3.2_opentelemetry.gemfile.lock +++ b/gemfiles/ruby_3.2_opentelemetry.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_opentracing.gemfile.lock b/gemfiles/ruby_3.2_opentracing.gemfile.lock index 076f32a6aa3..93f5289cfc9 100644 --- a/gemfiles/ruby_3.2_opentracing.gemfile.lock +++ b/gemfiles/ruby_3.2_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_rack_1.gemfile.lock b/gemfiles/ruby_3.2_rack_1.gemfile.lock index 00f14c04023..7581b051a2d 100644 --- a/gemfiles/ruby_3.2_rack_1.gemfile.lock +++ b/gemfiles/ruby_3.2_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_rack_2.gemfile.lock b/gemfiles/ruby_3.2_rack_2.gemfile.lock index 4951444be5e..27748b3ef00 100644 --- a/gemfiles/ruby_3.2_rack_2.gemfile.lock +++ b/gemfiles/ruby_3.2_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_rack_3.gemfile.lock b/gemfiles/ruby_3.2_rack_3.gemfile.lock index 41fc3f25fa3..37e813a76ca 100644 --- a/gemfiles/ruby_3.2_rack_3.gemfile.lock +++ b/gemfiles/ruby_3.2_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_rails61_mysql2.gemfile.lock b/gemfiles/ruby_3.2_rails61_mysql2.gemfile.lock index 1651cf7b11d..a0c6e20d9b9 100644 --- a/gemfiles/ruby_3.2_rails61_mysql2.gemfile.lock +++ b/gemfiles/ruby_3.2_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_rails61_postgres.gemfile.lock b/gemfiles/ruby_3.2_rails61_postgres.gemfile.lock index 61dea4d91cb..6c5ab018e1d 100644 --- a/gemfiles/ruby_3.2_rails61_postgres.gemfile.lock +++ b/gemfiles/ruby_3.2_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_rails61_postgres_redis.gemfile.lock b/gemfiles/ruby_3.2_rails61_postgres_redis.gemfile.lock index 87f1960c6ff..dcd9b311135 100644 --- a/gemfiles/ruby_3.2_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_3.2_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_3.2_rails61_postgres_sidekiq.gemfile.lock index 8b0f73ab559..90a2d7b2a8b 100644 --- a/gemfiles/ruby_3.2_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_3.2_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_rails61_semantic_logger.gemfile.lock b/gemfiles/ruby_3.2_rails61_semantic_logger.gemfile.lock index fa94a9fb66f..1e53d580434 100644 --- a/gemfiles/ruby_3.2_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_3.2_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_rails61_trilogy.gemfile.lock b/gemfiles/ruby_3.2_rails61_trilogy.gemfile.lock index 5390b30d9af..87d05079299 100644 --- a/gemfiles/ruby_3.2_rails61_trilogy.gemfile.lock +++ b/gemfiles/ruby_3.2_rails61_trilogy.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_redis_3.gemfile.lock b/gemfiles/ruby_3.2_redis_3.gemfile.lock index 7232d17f6d5..731bf0b1ab9 100644 --- a/gemfiles/ruby_3.2_redis_3.gemfile.lock +++ b/gemfiles/ruby_3.2_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_redis_4.gemfile.lock b/gemfiles/ruby_3.2_redis_4.gemfile.lock index 6db262df209..c2bed358dae 100644 --- a/gemfiles/ruby_3.2_redis_4.gemfile.lock +++ b/gemfiles/ruby_3.2_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_redis_5.gemfile.lock b/gemfiles/ruby_3.2_redis_5.gemfile.lock index 44a4e841292..05d160860d7 100644 --- a/gemfiles/ruby_3.2_redis_5.gemfile.lock +++ b/gemfiles/ruby_3.2_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_relational_db.gemfile.lock b/gemfiles/ruby_3.2_relational_db.gemfile.lock index 18453b6f846..412f807e4c2 100644 --- a/gemfiles/ruby_3.2_relational_db.gemfile.lock +++ b/gemfiles/ruby_3.2_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_resque2_redis3.gemfile.lock b/gemfiles/ruby_3.2_resque2_redis3.gemfile.lock index 60820e7809b..b0efa5a7dab 100644 --- a/gemfiles/ruby_3.2_resque2_redis3.gemfile.lock +++ b/gemfiles/ruby_3.2_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_resque2_redis4.gemfile.lock b/gemfiles/ruby_3.2_resque2_redis4.gemfile.lock index 4d945b4b8b5..a8eb8962e59 100644 --- a/gemfiles/ruby_3.2_resque2_redis4.gemfile.lock +++ b/gemfiles/ruby_3.2_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.2_sinatra.gemfile.lock b/gemfiles/ruby_3.2_sinatra.gemfile.lock index a7352dfa0e7..ed0e43add66 100644 --- a/gemfiles/ruby_3.2_sinatra.gemfile.lock +++ b/gemfiles/ruby_3.2_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_activesupport.gemfile.lock b/gemfiles/ruby_3.3_activesupport.gemfile.lock index 752844618c2..519aa4fa769 100644 --- a/gemfiles/ruby_3.3_activesupport.gemfile.lock +++ b/gemfiles/ruby_3.3_activesupport.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_aws.gemfile.lock b/gemfiles/ruby_3.3_aws.gemfile.lock index ae6fb738192..a71d24ec54c 100644 --- a/gemfiles/ruby_3.3_aws.gemfile.lock +++ b/gemfiles/ruby_3.3_aws.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_contrib.gemfile.lock b/gemfiles/ruby_3.3_contrib.gemfile.lock index 271e96b228b..bbccfa3dada 100644 --- a/gemfiles/ruby_3.3_contrib.gemfile.lock +++ b/gemfiles/ruby_3.3_contrib.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_contrib_old.gemfile.lock b/gemfiles/ruby_3.3_contrib_old.gemfile.lock index ec349f9dfd8..2500eedf25c 100644 --- a/gemfiles/ruby_3.3_contrib_old.gemfile.lock +++ b/gemfiles/ruby_3.3_contrib_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_core_old.gemfile.lock b/gemfiles/ruby_3.3_core_old.gemfile.lock index 69dc568c07e..480921ef292 100644 --- a/gemfiles/ruby_3.3_core_old.gemfile.lock +++ b/gemfiles/ruby_3.3_core_old.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_elasticsearch_7.gemfile.lock b/gemfiles/ruby_3.3_elasticsearch_7.gemfile.lock index c1e3c1d0de5..eb5c1a882fe 100644 --- a/gemfiles/ruby_3.3_elasticsearch_7.gemfile.lock +++ b/gemfiles/ruby_3.3_elasticsearch_7.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_elasticsearch_8.gemfile.lock b/gemfiles/ruby_3.3_elasticsearch_8.gemfile.lock index 0113cff23f2..707cbb9b16f 100644 --- a/gemfiles/ruby_3.3_elasticsearch_8.gemfile.lock +++ b/gemfiles/ruby_3.3_elasticsearch_8.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_graphql_1.12.gemfile.lock b/gemfiles/ruby_3.3_graphql_1.12.gemfile.lock index de15b31459d..12457fef28c 100644 --- a/gemfiles/ruby_3.3_graphql_1.12.gemfile.lock +++ b/gemfiles/ruby_3.3_graphql_1.12.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_graphql_1.13.gemfile.lock b/gemfiles/ruby_3.3_graphql_1.13.gemfile.lock index 5ed7a6fd0e5..9fa0d3d75d6 100644 --- a/gemfiles/ruby_3.3_graphql_1.13.gemfile.lock +++ b/gemfiles/ruby_3.3_graphql_1.13.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_graphql_2.0.gemfile.lock b/gemfiles/ruby_3.3_graphql_2.0.gemfile.lock index 0cdec8758db..e77cabaf779 100644 --- a/gemfiles/ruby_3.3_graphql_2.0.gemfile.lock +++ b/gemfiles/ruby_3.3_graphql_2.0.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_graphql_2.1.gemfile.lock b/gemfiles/ruby_3.3_graphql_2.1.gemfile.lock index 5e9ad03c994..807f9e8f49e 100644 --- a/gemfiles/ruby_3.3_graphql_2.1.gemfile.lock +++ b/gemfiles/ruby_3.3_graphql_2.1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_graphql_2.2.gemfile.lock b/gemfiles/ruby_3.3_graphql_2.2.gemfile.lock index 4ccb808b9e2..68b6db7c4ec 100644 --- a/gemfiles/ruby_3.3_graphql_2.2.gemfile.lock +++ b/gemfiles/ruby_3.3_graphql_2.2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_http.gemfile.lock b/gemfiles/ruby_3.3_http.gemfile.lock index 75660094a99..1923ebae189 100644 --- a/gemfiles/ruby_3.3_http.gemfile.lock +++ b/gemfiles/ruby_3.3_http.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_multi_rack_app.gemfile.lock b/gemfiles/ruby_3.3_multi_rack_app.gemfile.lock index d7e8058d739..417b9b392c6 100644 --- a/gemfiles/ruby_3.3_multi_rack_app.gemfile.lock +++ b/gemfiles/ruby_3.3_multi_rack_app.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_opensearch_2.gemfile.lock b/gemfiles/ruby_3.3_opensearch_2.gemfile.lock index 74fafa133f4..b2f83996762 100644 --- a/gemfiles/ruby_3.3_opensearch_2.gemfile.lock +++ b/gemfiles/ruby_3.3_opensearch_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_opensearch_3.gemfile.lock b/gemfiles/ruby_3.3_opensearch_3.gemfile.lock index 0e77f98aaed..6d66a947ca1 100644 --- a/gemfiles/ruby_3.3_opensearch_3.gemfile.lock +++ b/gemfiles/ruby_3.3_opensearch_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_opentelemetry.gemfile.lock b/gemfiles/ruby_3.3_opentelemetry.gemfile.lock index bd91448bdca..f63c8e22094 100644 --- a/gemfiles/ruby_3.3_opentelemetry.gemfile.lock +++ b/gemfiles/ruby_3.3_opentelemetry.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_opentracing.gemfile.lock b/gemfiles/ruby_3.3_opentracing.gemfile.lock index 897f9de00db..3902b46aef5 100644 --- a/gemfiles/ruby_3.3_opentracing.gemfile.lock +++ b/gemfiles/ruby_3.3_opentracing.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_rack_1.gemfile.lock b/gemfiles/ruby_3.3_rack_1.gemfile.lock index 6fb94e8816c..7f00f1648b0 100644 --- a/gemfiles/ruby_3.3_rack_1.gemfile.lock +++ b/gemfiles/ruby_3.3_rack_1.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_rack_2.gemfile.lock b/gemfiles/ruby_3.3_rack_2.gemfile.lock index b19b4374c44..383aeeb8a90 100644 --- a/gemfiles/ruby_3.3_rack_2.gemfile.lock +++ b/gemfiles/ruby_3.3_rack_2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_rack_3.gemfile.lock b/gemfiles/ruby_3.3_rack_3.gemfile.lock index 987f96213ee..7544f34fd27 100644 --- a/gemfiles/ruby_3.3_rack_3.gemfile.lock +++ b/gemfiles/ruby_3.3_rack_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_rails61_mysql2.gemfile.lock b/gemfiles/ruby_3.3_rails61_mysql2.gemfile.lock index dea84b5f1ab..d3637f3c0ef 100644 --- a/gemfiles/ruby_3.3_rails61_mysql2.gemfile.lock +++ b/gemfiles/ruby_3.3_rails61_mysql2.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_rails61_postgres.gemfile.lock b/gemfiles/ruby_3.3_rails61_postgres.gemfile.lock index 056ab9c3168..5b730cb9378 100644 --- a/gemfiles/ruby_3.3_rails61_postgres.gemfile.lock +++ b/gemfiles/ruby_3.3_rails61_postgres.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_rails61_postgres_redis.gemfile.lock b/gemfiles/ruby_3.3_rails61_postgres_redis.gemfile.lock index e4d334bbd36..caa1c2b5532 100644 --- a/gemfiles/ruby_3.3_rails61_postgres_redis.gemfile.lock +++ b/gemfiles/ruby_3.3_rails61_postgres_redis.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_rails61_postgres_sidekiq.gemfile.lock b/gemfiles/ruby_3.3_rails61_postgres_sidekiq.gemfile.lock index 94024310d09..77bb36a94f2 100644 --- a/gemfiles/ruby_3.3_rails61_postgres_sidekiq.gemfile.lock +++ b/gemfiles/ruby_3.3_rails61_postgres_sidekiq.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_rails61_semantic_logger.gemfile.lock b/gemfiles/ruby_3.3_rails61_semantic_logger.gemfile.lock index 7ad65053df9..a115f1b1671 100644 --- a/gemfiles/ruby_3.3_rails61_semantic_logger.gemfile.lock +++ b/gemfiles/ruby_3.3_rails61_semantic_logger.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_rails61_trilogy.gemfile.lock b/gemfiles/ruby_3.3_rails61_trilogy.gemfile.lock index d6848696652..b9f659b735d 100644 --- a/gemfiles/ruby_3.3_rails61_trilogy.gemfile.lock +++ b/gemfiles/ruby_3.3_rails61_trilogy.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_redis_3.gemfile.lock b/gemfiles/ruby_3.3_redis_3.gemfile.lock index 00c781f0a2f..05361022c25 100644 --- a/gemfiles/ruby_3.3_redis_3.gemfile.lock +++ b/gemfiles/ruby_3.3_redis_3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_redis_4.gemfile.lock b/gemfiles/ruby_3.3_redis_4.gemfile.lock index 0651eb6c902..adda912da4f 100644 --- a/gemfiles/ruby_3.3_redis_4.gemfile.lock +++ b/gemfiles/ruby_3.3_redis_4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_redis_5.gemfile.lock b/gemfiles/ruby_3.3_redis_5.gemfile.lock index 6621a369b8c..34a4b39f447 100644 --- a/gemfiles/ruby_3.3_redis_5.gemfile.lock +++ b/gemfiles/ruby_3.3_redis_5.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_relational_db.gemfile.lock b/gemfiles/ruby_3.3_relational_db.gemfile.lock index cd1d13f7a6f..c3694699c8a 100644 --- a/gemfiles/ruby_3.3_relational_db.gemfile.lock +++ b/gemfiles/ruby_3.3_relational_db.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_resque2_redis3.gemfile.lock b/gemfiles/ruby_3.3_resque2_redis3.gemfile.lock index 646dc425001..985bbfa9df1 100644 --- a/gemfiles/ruby_3.3_resque2_redis3.gemfile.lock +++ b/gemfiles/ruby_3.3_resque2_redis3.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_resque2_redis4.gemfile.lock b/gemfiles/ruby_3.3_resque2_redis4.gemfile.lock index f8859897967..3754c3c49da 100644 --- a/gemfiles/ruby_3.3_resque2_redis4.gemfile.lock +++ b/gemfiles/ruby_3.3_resque2_redis4.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) diff --git a/gemfiles/ruby_3.3_sinatra.gemfile.lock b/gemfiles/ruby_3.3_sinatra.gemfile.lock index af882ccb980..c999773205e 100644 --- a/gemfiles/ruby_3.3_sinatra.gemfile.lock +++ b/gemfiles/ruby_3.3_sinatra.gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: .. specs: - ddtrace (1.23.2) + ddtrace (1.23.3) datadog-ci (~> 0.8.1) debase-ruby_core_source (= 3.3.1) libdatadog (~> 7.0.0.1.0) From 0fe5d2c4933bdff8a37f648c24381aee400e9ac2 Mon Sep 17 00:00:00 2001 From: Ivo Anjo Date: Wed, 3 Jul 2024 15:13:53 +0100 Subject: [PATCH 37/49] Use minimalistic post-install upgrade message **What does this PR do?** This PR is a follow-up on #3723. For the 1.23.3 dd-trace-rb release, we included a quite detailed post-install message to tell customers that the new release was out: ``` Thank you for installing ddtrace. We have released our next major version! As of version 2, `ddtrace` gem has been renamed to `datadog`. The 1.x series will now only receive maintenance updates for security and critical bug fixes. To upgrade, please replace gem `ddtrace` with gem `datadog`. For detailed instructions on migration, see: https://dtdg.co/ruby-v2-upgrade ``` My thinking is -- some customers may not be able to move to 2.x as quickly as they wanted, and thus seeing that message again and again may start to be slightly annoying. Thus, this PR replaces with with the minimalistic ``` The ddtrace gem has been renamed to datadog. We recommend upgrading: https://dtdg.co/ruby-v2-upgrade ``` **Motivation:** Continue suggesting to customers that the should upgrade, while at the same time not being too annoying about it. **Additional Notes:** It actually may not a half-bad idea that we released a version with the big message, and then shorted in. Specifically, customers that mostly keep up-to-date will probably see that message quite quickly, and thus upgrade. For the long tail of customers that may need to remain on 1.x, the more minimalistic message that will go out in a few weeks/months on a future 1.x maintenance release will continue to remind them. **How to test the change?** ```bash $ bundle exec rake build # ... ddtrace 1.23.3 built to pkg/ddtrace-1.23.3.gem. $ gem install pkg/ddtrace-1.23.3.gem Building native extensions. This could take a while... The ddtrace gem has been renamed to datadog. We recommend upgrading: https://dtdg.co/ruby-v2-upgrade ``` --- ddtrace.gemspec | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/ddtrace.gemspec b/ddtrace.gemspec index a549a0186b8..0477ad13e1d 100644 --- a/ddtrace.gemspec +++ b/ddtrace.gemspec @@ -77,12 +77,6 @@ Gem::Specification.new do |spec| spec.extensions = ['ext/datadog_profiling_native_extension/extconf.rb', 'ext/datadog_profiling_loader/extconf.rb'] spec.post_install_message = <<-MSG - Thank you for installing ddtrace. We have released our next major version! - - As of version 2, `ddtrace` gem has been renamed to `datadog`. - The 1.x series will now only receive maintenance updates for security and critical bug fixes. - - To upgrade, please replace gem `ddtrace` with gem `datadog`. - For detailed instructions on migration, see: https://dtdg.co/ruby-v2-upgrade + The ddtrace gem has been renamed to datadog. We recommend upgrading: https://dtdg.co/ruby-v2-upgrade MSG end From 545ff0868eff0500759177de32c4b7033b7a612a Mon Sep 17 00:00:00 2001 From: Ivo Anjo Date: Mon, 8 Jul 2024 12:32:28 +0100 Subject: [PATCH 38/49] Tweak post install message after PR discussion --- ddtrace.gemspec | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ddtrace.gemspec b/ddtrace.gemspec index 0477ad13e1d..f652dc40d7a 100644 --- a/ddtrace.gemspec +++ b/ddtrace.gemspec @@ -77,6 +77,7 @@ Gem::Specification.new do |spec| spec.extensions = ['ext/datadog_profiling_native_extension/extconf.rb', 'ext/datadog_profiling_loader/extconf.rb'] spec.post_install_message = <<-MSG - The ddtrace gem has been renamed to datadog. We recommend upgrading: https://dtdg.co/ruby-v2-upgrade + The ddtrace gem has been renamed to datadog in version 2. Upgrading is easy: https://dtdg.co/ruby-v2-upgrade + ddtrace 1.x will only receive security updates and critical bug fixes. MSG end From cb3418c3d60f9e0381656892501ba9a203e65f7b Mon Sep 17 00:00:00 2001 From: David Elner Date: Thu, 11 Jul 2024 14:14:55 -0400 Subject: [PATCH 39/49] Added: Core::Deprecations and limiting function --- lib/datadog/core.rb | 21 +----- lib/datadog/core/deprecations.rb | 58 ++++++++++++++++ sig/datadog/core.rbs | 1 + sig/datadog/core/deprecations.rbs | 22 +++++++ spec/datadog/core/deprecations_spec.rb | 91 ++++++++++++++++++++++++++ spec/datadog/core_spec.rb | 37 +---------- 6 files changed, 175 insertions(+), 55 deletions(-) create mode 100644 lib/datadog/core/deprecations.rb create mode 100644 sig/datadog/core/deprecations.rbs create mode 100644 spec/datadog/core/deprecations_spec.rb diff --git a/lib/datadog/core.rb b/lib/datadog/core.rb index 2f56cb785a7..86264868513 100644 --- a/lib/datadog/core.rb +++ b/lib/datadog/core.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true +require_relative 'core/deprecations' require_relative 'core/extensions' # We must load core extensions to make certain global APIs @@ -9,25 +10,7 @@ module Datadog # products. It is a dependency of each product. Contrast with Datadog::Kit # for higher-level features. module Core - class << self - # Records the occurrence of a deprecated operation in this library. - # - # Currently, these operations are logged to `Datadog.logger` at `warn` level. - # - # `disallowed_next_major` adds a message informing that the deprecated operation - # won't be allowed in the next major release. - # - # @yieldreturn [String] a String with the lazily evaluated deprecation message. - # @param [Boolean] disallowed_next_major whether this deprecation will be enforced in the next major release. - def log_deprecation(disallowed_next_major: true) - Datadog.logger.warn do - message = yield - message += ' This will be enforced in the next major release.' if disallowed_next_major - message - end - nil - end - end + extend Core::Deprecations end extend Core::Extensions diff --git a/lib/datadog/core/deprecations.rb b/lib/datadog/core/deprecations.rb new file mode 100644 index 00000000000..01d134eac16 --- /dev/null +++ b/lib/datadog/core/deprecations.rb @@ -0,0 +1,58 @@ +# frozen_string_literal: true + +module Datadog + module Core + # Contains behavior for handling deprecated functions in the codebase. + module Deprecations + # Records the occurrence of a deprecated operation in this library. + # + # Currently, these operations are logged to `Datadog.logger` at `warn` level. + # + # `disallowed_next_major` adds a message informing that the deprecated operation + # won't be allowed in the next major release. + # + # @yieldreturn [String] a String with the lazily evaluated deprecation message. + # @param [Boolean] disallowed_next_major whether this deprecation will be enforced in the next major release. + # @param [Object] key A unique key for the deprecation. Only the first message with the same key will be logged. + def log_deprecation(disallowed_next_major: true, key: nil) + return unless log_deprecation?(key) + + Datadog.logger.warn do + message = yield + message += ' This will be enforced in the next major release.' if disallowed_next_major + message + end + + # Track the deprecation being logged. + deprecation_logged!(key) + + nil + end + + private + + # Determines whether a deprecation message should be logged. + # + # Internal use only. + def log_deprecation?(key) + return true if key.nil? + + # Only allow a deprecation to be logged once. + !logged_deprecations.key?(key) + end + + def deprecation_logged!(key) + return if key.nil? + + logged_deprecations[key] += 1 + end + + # Tracks what deprecation warnings have already been logged + # + # Internal use only. + def logged_deprecations + @logged_deprecations ||= Hash.new(0) + end + end + end +end diff --git a/sig/datadog/core.rbs b/sig/datadog/core.rbs index 410f4f2cd29..8f99173d43f 100644 --- a/sig/datadog/core.rbs +++ b/sig/datadog/core.rbs @@ -2,6 +2,7 @@ module Datadog module Core end + extend Core::Deprecations extend Core::Configuration extend Tracing::Contrib::Extensions::Helpers end diff --git a/sig/datadog/core/deprecations.rbs b/sig/datadog/core/deprecations.rbs new file mode 100644 index 00000000000..b3c42daa071 --- /dev/null +++ b/sig/datadog/core/deprecations.rbs @@ -0,0 +1,22 @@ +module Datadog + module Core + module Deprecations + interface _Hashing + def hash: () -> ::Integer + def eql?: (untyped) -> bool + def nil?: () -> bool + end + + type key = _Hashing + + @logged_deprecations: ::Hash[key, ::Integer] + def log_deprecation: (?disallowed_next_major: bool, ?key: key?) { () -> String } -> void + + private + def log_deprecation?: (key key) -> bool + + def deprecation_logged!: (key key) -> void + def logged_deprecations: () -> ::Hash[key, ::Integer] + end + end +end diff --git a/spec/datadog/core/deprecations_spec.rb b/spec/datadog/core/deprecations_spec.rb new file mode 100644 index 00000000000..e084a3e8f8f --- /dev/null +++ b/spec/datadog/core/deprecations_spec.rb @@ -0,0 +1,91 @@ +require 'spec_helper' + +require 'datadog/core/deprecations' + +RSpec.describe Datadog::Core::Deprecations do + context 'when extended' do + subject(:test_class) { Class.new { extend Datadog::Core::Deprecations } } + + describe '.log_deprecation' do + subject(:log_deprecation) { call_log_deprecation } + + let(:options) { {} } + let(:message) { 'Longer allowed.' } + + def call_log_deprecation + test_class.log_deprecation(**options) { message } + end + + context 'by default' do + it 'warns with enforcement message' do + expect(Datadog.logger).to receive(:warn) do |&block| + expect(block.call).to eq('Longer allowed. This will be enforced in the next major release.') + end + log_deprecation + end + + it 'does not limit messages' do + expect(Datadog.logger).to receive(:warn).twice + 2.times { call_log_deprecation } + end + end + + context 'with disallowed_next_major:' do + let(:options) { { disallowed_next_major: disallowed_next_major } } + + context 'true' do + let(:disallowed_next_major) { true } + + it 'warns with enforcement message' do + expect(Datadog.logger).to receive(:warn) do |&block| + expect(block.call).to eq('Longer allowed. This will be enforced in the next major release.') + end + log_deprecation + end + end + + context 'false' do + let(:disallowed_next_major) { false } + + it 'warns with enforcement message' do + expect(Datadog.logger).to receive(:warn) do |&block| + expect(block.call).to eq('Longer allowed.') + end + log_deprecation + end + end + end + + context 'with key:' do + let(:options) { { key: key } } + + context 'nil' do + let(:key) { nil } + + it 'does not limit messages' do + expect(Datadog.logger).to receive(:warn).twice + 2.times { call_log_deprecation } + end + end + + context 'Symbol' do + let(:key) { :deprecated_setting } + + it 'limits messages' do + expect(Datadog.logger).to receive(:warn).once + 2.times { call_log_deprecation } + end + end + + context 'String' do + let(:key) { 'deprecated_setting' } + + it 'limits messages' do + expect(Datadog.logger).to receive(:warn).once + 2.times { call_log_deprecation } + end + end + end + end + end +end diff --git a/spec/datadog/core_spec.rb b/spec/datadog/core_spec.rb index a979921dd06..194de852de8 100644 --- a/spec/datadog/core_spec.rb +++ b/spec/datadog/core_spec.rb @@ -3,42 +3,7 @@ require 'datadog/core' RSpec.describe Datadog::Core do - describe '.log_deprecation' do - subject(:log_deprecation) { described_class.log_deprecation(**options) { message } } - let(:options) { {} } - let(:message) { 'Longer allowed.' } - - context 'by default' do - it 'warns with enforcement message' do - expect(Datadog.logger).to receive(:warn) do |&block| - expect(block.call).to eq('Longer allowed. This will be enforced in the next major release.') - end - log_deprecation - end - end - - context 'with disallowed_next_major true' do - let(:options) { { disallowed_next_major: true } } - - it 'warns with enforcement message' do - expect(Datadog.logger).to receive(:warn) do |&block| - expect(block.call).to eq('Longer allowed. This will be enforced in the next major release.') - end - log_deprecation - end - end - - context 'with disallowed_next_major false' do - let(:options) { { disallowed_next_major: false } } - - it 'warns with enforcement message' do - expect(Datadog.logger).to receive(:warn) do |&block| - expect(block.call).to eq('Longer allowed.') - end - log_deprecation - end - end - end + it { expect(described_class).to be_a_kind_of(Datadog::Core::Deprecations) } end RSpec.describe Datadog do From 8b4b2e77697fb381c4419519d9e9b5f2a0ac7337 Mon Sep 17 00:00:00 2001 From: Marco Costa Date: Wed, 26 Jun 2024 15:11:19 -0400 Subject: [PATCH 40/49] Merge pull request #3731 from DataDog/trace-disabled-fix --- lib/datadog/tracing.rb | 4 +++- spec/datadog/tracing_spec.rb | 10 ++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/lib/datadog/tracing.rb b/lib/datadog/tracing.rb index 26cbd3ddadb..12001319861 100644 --- a/lib/datadog/tracing.rb +++ b/lib/datadog/tracing.rb @@ -96,9 +96,11 @@ def correlation # # dd.env=prod dd.service=auth dd.version=13.8 dd.trace_id=5458478252992251 dd.span_id=7117552347370098 My message # ``` # - # @return [String] correlation information + # @return [String] correlation information; or an empty String if Tracing is disabled (`!enabled?`) # @public_api def log_correlation + return '' unless enabled? + correlation.to_log_format end diff --git a/spec/datadog/tracing_spec.rb b/spec/datadog/tracing_spec.rb index dfd63111196..74914b6ea7b 100644 --- a/spec/datadog/tracing_spec.rb +++ b/spec/datadog/tracing_spec.rb @@ -106,6 +106,16 @@ expect(log_correlation).to eq(returned) end # rubocop:enable RSpec/MessageChain + + context 'with tracing disabled' do + before do + allow(Datadog.send(:components).tracer).to receive(:enabled).and_return(false) + end + + it 'returns an empty string' do + expect(log_correlation).to eq('') + end + end end describe '.shutdown!' do From 1f37a23a00f99962e84a5eb9880646358d1122e8 Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Fri, 30 Aug 2024 11:36:49 +0200 Subject: [PATCH 41/49] Disable persist-credentials when checking out system tests --- .github/workflows/lib-injection.yml | 4 +++- .github/workflows/system-tests.yml | 4 ++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/lib-injection.yml b/.github/workflows/lib-injection.yml index 95df541751f..332a39be93e 100644 --- a/.github/workflows/lib-injection.yml +++ b/.github/workflows/lib-injection.yml @@ -58,9 +58,10 @@ jobs: uses: actions/checkout@v4 with: repository: 'DataDog/system-tests' + persist-credentials: false - name: Install runner - uses: ./.github/actions/install_runner + uses: ./.github/actions/install_runner - name: Run K8s Lib Injection Tests run: ./run.sh K8S_LIB_INJECTION_BASIC @@ -91,6 +92,7 @@ jobs: uses: actions/checkout@v4 with: repository: DataDog/system-tests + persist-credentials: false path: system-tests - name: Overwrite auto inject script with commit SHA run: | diff --git a/.github/workflows/system-tests.yml b/.github/workflows/system-tests.yml index c4ce4e5014d..c6dbf3b672a 100644 --- a/.github/workflows/system-tests.yml +++ b/.github/workflows/system-tests.yml @@ -31,6 +31,7 @@ jobs: uses: actions/checkout@v4 with: repository: 'DataDog/system-tests' + persist-credentials: false - name: Pull released image run: | if docker pull ${{ env.REPO }}/system-tests/${{ matrix.image.name }}:latest; then @@ -104,6 +105,7 @@ jobs: uses: actions/checkout@v4 with: repository: 'DataDog/system-tests' + persist-credentials: false - name: Checkout ${{ matrix.library.repository }} uses: actions/checkout@v4 with: @@ -250,6 +252,7 @@ jobs: uses: actions/checkout@v4 with: repository: 'DataDog/system-tests' + persist-credentials: false - name: Pull runner image run: | docker pull ${{ env.REPO }}/system-tests/runner:gha${{ github.run_id }}-g${{ github.sha }} @@ -316,6 +319,7 @@ jobs: uses: actions/checkout@v4 with: repository: 'DataDog/system-tests' + persist-credentials: false - name: Retrieve logs uses: actions/download-artifact@v4 with: From abc8342d906d505f70768d44048f63a955a7b369 Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Mon, 2 Sep 2024 11:59:11 +0200 Subject: [PATCH 42/49] Backport lib injection test --- .github/workflows/lib-injection.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/lib-injection.yml b/.github/workflows/lib-injection.yml index 332a39be93e..01acdad3551 100644 --- a/.github/workflows/lib-injection.yml +++ b/.github/workflows/lib-injection.yml @@ -50,8 +50,8 @@ jobs: env: TEST_LIBRARY: ruby WEBLOG_VARIANT: ${{ matrix.weblog-variant }} - DOCKER_REGISTRY_IMAGES_PATH: ghcr.io/datadog - DOCKER_IMAGE_TAG: ${{ github.sha }} + LIB_INIT_IMAGE: ghcr.io/datadog/dd-trace-rb/dd-lib-ruby-init:${{ github.sha }} + LIBRARY_INJECTION_TEST_APP_IMAGE: ghcr.io/datadog/system-tests/${{ matrix.weblog-variant }}:latest BUILDX_PLATFORMS: linux/amd64,linux/arm64/v8 steps: - name: Checkout system tests @@ -64,7 +64,7 @@ jobs: uses: ./.github/actions/install_runner - name: Run K8s Lib Injection Tests - run: ./run.sh K8S_LIB_INJECTION_BASIC + run: ./run.sh K8S_LIBRARY_INJECTION_BASIC - name: Compress logs id: compress_logs From 425e9883665284935f7de1a19dfdec6e08d74286 Mon Sep 17 00:00:00 2001 From: Loic Nageleisen Date: Fri, 30 Aug 2024 13:00:56 +0200 Subject: [PATCH 43/49] Fix update-gemfiles workflow permissions No permission is declared in the workflow file, when a switch to a more restrictive global setting would cause the workflow to fail. --- .github/workflows/update-gemfiles.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/update-gemfiles.yml b/.github/workflows/update-gemfiles.yml index e0cbbd0cedb..b6d463d05d3 100644 --- a/.github/workflows/update-gemfiles.yml +++ b/.github/workflows/update-gemfiles.yml @@ -29,6 +29,9 @@ jobs: check: name: Update Gemfiles runs-on: ubuntu-22.04 + permissions: + contents: write + pull-requests: write steps: # Only execute if there's a PR attached to this branch. # Because we execute on `push`, we have to double check here if this is part of a PR. From 88c7723ebb543a335b2e0867900808598cac0d19 Mon Sep 17 00:00:00 2001 From: roberto montero Date: Wed, 17 Jul 2024 15:59:27 +0200 Subject: [PATCH 44/49] Onboarding and k8s lib injection tests: Remove deprecated scenarios (avoid deb and rpm) --- .gitlab-ci.yml | 20 ++++++-------------- .gitlab/onboarding_tests.yml | 34 ---------------------------------- 2 files changed, 6 insertions(+), 48 deletions(-) delete mode 100644 .gitlab/onboarding_tests.yml diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index e68fed81440..a6daadd47a8 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -9,7 +9,7 @@ stages: include: - remote: https://gitlab-templates.ddbuild.io/apm/packaging.yml - local: ".gitlab/benchmarks.yml" - - local: ".gitlab/onboarding_tests.yml" + - remote: https://gitlab-templates.ddbuild.io/libdatadog/include/single-step-instrumentation-tests.yml variables: DOWNSTREAM_BRANCH: @@ -199,27 +199,19 @@ oci-internal-test-ecr-publish: IMG_REGISTRIES: agent-qa onboarding_tests: - extends: .base_job_onboarding_tests + extends: .base_job_onboarding stage: integration-tests - needs: [ package-amd64, package-arm64, oci-internal-test-ecr-publish] + needs: [ oci-internal-test-ecr-publish ] allow_failure: false variables: TEST_LIBRARY: ruby - ONBOARDING_FILTER_ENV: prod + SCENARIO: SIMPLE_INSTALLER_AUTO_INJECTION + DD_INSTALLER_LIBRARY_VERSION: pipeline-${CI_PIPELINE_ID} parallel: matrix: - - ONBOARDING_FILTER_WEBLOG: [test-app-ruby] - SCENARIO: [SIMPLE_HOST_AUTO_INJECTION] - - ONBOARDING_FILTER_WEBLOG: [test-app-ruby-container] - SCENARIO: [SIMPLE_CONTAINER_AUTO_INJECTION] - - ONBOARDING_FILTER_WEBLOG: [test-app-ruby,test-app-ruby-container] - SCENARIO: [INSTALLER_AUTO_INJECTION] + - ONBOARDING_FILTER_WEBLOG: [test-app-ruby, test-app-ruby-container] script: - git clone https://git@github.com/DataDog/system-tests.git system-tests - - cp packaging/*.rpm system-tests/binaries - - cp packaging/*.deb system-tests/binaries - - export DD_INSTALLER_LIBRARY_VERSION="pipeline-${CI_PIPELINE_ID}" - - ls system-tests/binaries - cd system-tests - ./build.sh -i runner - timeout 2700s ./run.sh $SCENARIO --vm-weblog ${ONBOARDING_FILTER_WEBLOG} --vm-env prod --vm-library ${TEST_LIBRARY} --vm-provider aws --vm-skip-branches ubuntu18_amd64 diff --git a/.gitlab/onboarding_tests.yml b/.gitlab/onboarding_tests.yml deleted file mode 100644 index 1ad4471659a..00000000000 --- a/.gitlab/onboarding_tests.yml +++ /dev/null @@ -1,34 +0,0 @@ -.base_job_onboarding_tests: - - image: 486234852809.dkr.ecr.us-east-1.amazonaws.com/ci/test-infra-definitions/runner:a58cc31c - tags: ["arch:amd64"] - before_script: - # Setup AWS Credentials for dd-trace-rb. - - mkdir -p ~/.aws - - aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.agent-qa-profile --with-decryption --query "Parameter.Value" --out text >> ~/.aws/config - - export DD_API_KEY_ONBOARDING=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.dd-api-key-onboarding --with-decryption --query "Parameter.Value" --out text) - - export DD_APP_KEY_ONBOARDING=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.dd-app-key-onboarding --with-decryption --query "Parameter.Value" --out text) - - export ONBOARDING_AWS_INFRA_SUBNET_ID=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.aws-infra-subnet-id --with-decryption --query "Parameter.Value" --out text) - - export ONBOARDING_AWS_INFRA_SECURITY_GROUPS_ID=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.aws-infra-securiy-groups-id --with-decryption --query "Parameter.Value" --out text) - - export ONBOARDING_AWS_INFRA_IAM_INSTANCE_PROFILE=ec2InstanceRole - - export PULUMI_CONFIG_PASSPHRASE=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.pulumi-config-passphrase --with-decryption --query "Parameter.Value" --out text) - #Install plugins for PULUMI you need connect to gh. Sometimes this problem arises: GitHub rate limit exceeded - - export GITHUB_TOKEN=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.gh-token --with-decryption --query "Parameter.Value" --out text) - #Avoid dockerhub rate limits - - export DOCKER_LOGIN=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.docker-login --with-decryption --query "Parameter.Value" --out text) - - export DOCKER_LOGIN_PASS=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-rb.docker-login-pass --with-decryption --query "Parameter.Value" --out text) - - export AWS_PROFILE=agent-qa-ci - - pulumi login --local #"s3://dd-pulumi-state?region=us-east-1&awssdk=v2&profile=$AWS_PROFILE" - - pulumi plugin install resource command 0.7.2 - - pulumi plugin install resource aws 5.41.0 - - after_script: - - echo "After onboarding script" - - cd system-tests - - mkdir -p reports - - cp -R logs_*/ reports/ - - artifacts: - when: always - paths: - - system-tests/reports/ From 99a0138c9e730958b869deba5fc9590836c7fd7a Mon Sep 17 00:00:00 2001 From: Yury Lebedev Date: Fri, 30 Aug 2024 16:04:16 +0200 Subject: [PATCH 45/49] Fix permissions system-tests workflow We need write permissions to push images to registry. --- .github/workflows/system-tests.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/system-tests.yml b/.github/workflows/system-tests.yml index c6dbf3b672a..b7d59b528cf 100644 --- a/.github/workflows/system-tests.yml +++ b/.github/workflows/system-tests.yml @@ -25,6 +25,8 @@ jobs: - name: proxy internal: datadog/system-tests:proxy-v1 runs-on: ubuntu-latest + permissions: + packages: write name: Build (${{ matrix.image.name }}) steps: - name: Checkout @@ -100,6 +102,8 @@ jobs: - rails71 runs-on: ubuntu-latest name: Build (${{ matrix.app }}) + permissions: + packages: write steps: - name: Checkout uses: actions/checkout@v4 From aa261f4d1eebf9d1a7206804950768c6d492bbf6 Mon Sep 17 00:00:00 2001 From: Marco Costa Date: Thu, 12 Sep 2024 15:04:34 -0700 Subject: [PATCH 46/49] Fix Ruby 3.3 warning for ostruct removal --- spec/datadog/core/environment/execution_spec.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spec/datadog/core/environment/execution_spec.rb b/spec/datadog/core/environment/execution_spec.rb index ef39af0b5e5..ec57ff5b0d9 100644 --- a/spec/datadog/core/environment/execution_spec.rb +++ b/spec/datadog/core/environment/execution_spec.rb @@ -71,7 +71,7 @@ f.close out, = Open3.capture2e('pry', '-f', '--noprompt', f.path) - expect(out).to eq('ACTUAL:true') + expect(out).to include('ACTUAL:true') end end end From 36870daed9d25206a882fef43e90422ec2bb710e Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Fri, 13 Sep 2024 01:59:52 +0200 Subject: [PATCH 47/49] Fix permission --- .github/workflows/lib-injection.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/lib-injection.yml b/.github/workflows/lib-injection.yml index 01acdad3551..dd5d1891579 100644 --- a/.github/workflows/lib-injection.yml +++ b/.github/workflows/lib-injection.yml @@ -6,6 +6,8 @@ on: jobs: build-and-publish-test-image: runs-on: ubuntu-latest + permissions: + packages: write steps: - uses: actions/checkout@v4 - name: Set up QEMU From a519a4aaebd9a11dfc9091641476484915fee011 Mon Sep 17 00:00:00 2001 From: TonyCTHsu Date: Thu, 1 Aug 2024 14:34:55 +0200 Subject: [PATCH 48/49] Merge pull request #3821 from DataDog/tonycthsu/fix-integration Pin passenger version for integration test --- integration/apps/rack/Gemfile | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/integration/apps/rack/Gemfile b/integration/apps/rack/Gemfile index c1a031be60d..33dde3a3e30 100644 --- a/integration/apps/rack/Gemfile +++ b/integration/apps/rack/Gemfile @@ -4,7 +4,11 @@ source "https://rubygems.org" gem 'puma' gem 'unicorn' -gem 'passenger' +if RUBY_VERSION < '2.6.0' + gem 'passenger', '< 6.0.23' +else + gem 'passenger' +end gem 'rack' gem 'rackup' if RUBY_VERSION >= '2.4' # The `rackup` is its own gem since Rack 3.0 From ec2c75a1659f6076f23f33516e7318fb9270e2ee Mon Sep 17 00:00:00 2001 From: Tony Hsu Date: Fri, 6 Sep 2024 17:34:56 +0200 Subject: [PATCH 49/49] Improve brittle assertion --- .../core/environment/execution_spec.rb | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/spec/datadog/core/environment/execution_spec.rb b/spec/datadog/core/environment/execution_spec.rb index ec57ff5b0d9..bb3b9f1fe90 100644 --- a/spec/datadog/core/environment/execution_spec.rb +++ b/spec/datadog/core/environment/execution_spec.rb @@ -57,10 +57,10 @@ context 'when in an IRB session' do it 'returns true' do - _, err = Bundler.with_clean_env do # Ruby 2.6 does not have irb by default in a bundle, but has it outside of it. - Open3.capture3('irb', '--noprompt', '--noverbose', stdin_data: repl_script) + _, err, = Bundler.with_clean_env do # Ruby 2.6 does not have irb by default in a bundle, but has it outside of it. + Open3.capture3('irb', '--noprompt', '--noverbose', '--noecho', stdin_data: repl_script) end - expect(err).to end_with('true') + expect(err).to end_with('ACTUAL:true') end end @@ -70,8 +70,8 @@ f.write(repl_script) f.close - out, = Open3.capture2e('pry', '-f', '--noprompt', f.path) - expect(out).to include('ACTUAL:true') + _, err, = Open3.capture3('pry', '-f', '--noprompt', f.path) + expect(err).to end_with('ACTUAL:true') end end end @@ -128,7 +128,7 @@ def test_it_does_something_useful it 'returns true' do _, err, = Open3.capture3('ruby', stdin_data: script) - expect(err).to end_with('true') + expect(err).to end_with('ACTUAL:true') end end @@ -186,9 +186,10 @@ def test_it_does_something_useful # Add our script to `env.rb`, which is always run before any feature is executed. File.write('features/support/env.rb', repl_script) - _, err = Bundler.with_clean_env do + _, err, = Bundler.with_clean_env do Open3.capture3('ruby', stdin_data: script) end + expect(err).to include('ACTUAL:true') end end @@ -252,7 +253,7 @@ def test_it_does_something_useful context 'when given WebMock', skip: Gem::Version.new(Bundler::VERSION) < Gem::Version.new('2') do it do - out, err = Bundler.with_clean_env do + out, = Bundler.with_clean_env do Open3.capture3('ruby', stdin_data: <<-RUBY require 'bundler/inline' @@ -268,13 +269,12 @@ def test_it_does_something_useful $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) require 'datadog/core/environment/execution' - STDOUT.print Datadog::Core::Environment::Execution.webmock_enabled? + STDOUT.print "ACTUAL:\#{Datadog::Core::Environment::Execution.webmock_enabled?}" RUBY ) end - expect(err).to be_empty - expect(out).to eq('true') + expect(out).to end_with('ACTUAL:true') end end end