ddtrace 0.50.0 → 0.53.0

data/lib/ddtrace/profiling/collectors/stack.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/profiling/backtrace_location'
 require 'ddtrace/profiling/events/stack'
 require 'ddtrace/utils/only_once'
@@ -11,17 +12,23 @@ module Datadog
       # Collects stack trace samples from Ruby threads for both CPU-time (if available) and wall-clock.
       # Runs on its own background thread.
       #
-      # rubocop:disable Metrics/ClassLength
-      class Stack < Worker
+      class Stack < Worker # rubocop:disable Metrics/ClassLength
         include Workers::Polling
 
         DEFAULT_MAX_TIME_USAGE_PCT = 2.0
         MIN_INTERVAL = 0.01
         THREAD_LAST_CPU_TIME_KEY = :datadog_profiler_last_cpu_time
+        THREAD_LAST_WALL_CLOCK_KEY = :datadog_profiler_last_wall_clock
+
+        # This default was picked based on the current sampling performance and on expected concurrency on an average
+        # Ruby MRI application. Lowering this optimizes for latency (less impact each time we sample), and raising
+        # optimizes for coverage (less chance to miss what a given thread is doing).
+        DEFAULT_MAX_THREADS_SAMPLED = 16
 
         attr_reader \
           :recorder,
           :max_frames,
+          :trace_identifiers_helper,
           :ignore_thread,
           :max_time_usage_pct,
           :thread_api
@@ -29,8 +36,10 @@ module Datadog
         def initialize(
           recorder,
           max_frames:,
+          trace_identifiers_helper:, # Usually an instance of Datadog::Profiling::TraceIdentifiers::Helper
           ignore_thread: nil,
           max_time_usage_pct: DEFAULT_MAX_TIME_USAGE_PCT,
+          max_threads_sampled: DEFAULT_MAX_THREADS_SAMPLED,
           thread_api: Thread,
           fork_policy: Workers::Async::Thread::FORK_POLICY_RESTART, # Restart in forks by default
           interval: MIN_INTERVAL,
@@ -38,8 +47,10 @@ module Datadog
         )
           @recorder = recorder
           @max_frames = max_frames
+          @trace_identifiers_helper = trace_identifiers_helper
           @ignore_thread = ignore_thread
           @max_time_usage_pct = max_time_usage_pct
+          @max_threads_sampled = max_threads_sampled
           @thread_api = thread_api
 
           # Workers::Async::Thread settings
@@ -57,10 +68,13 @@ module Datadog
           @build_backtrace_location = method(:build_backtrace_location).to_proc
           # Cache this buffer, since it's pretty expensive to keep accessing it
           @stack_sample_event_recorder = recorder[Events::StackSample]
+          # See below for details on why this is needed
+          @needs_process_waiter_workaround =
+            Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.3') &&
+            Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.7')
         end
 
         def start
-          @last_wall_time = Datadog::Utils::Time.get_time
           reset_cpu_time_tracking
           perform
         end
@@ -84,24 +98,14 @@ module Datadog
 
         def collect_events
           events = []
-
-          # Compute wall time interval
-          current_wall_time = Datadog::Utils::Time.get_time
-          last_wall_time = if instance_variable_defined?(:@last_wall_time)
-                             @last_wall_time
-                           else
-                             current_wall_time
-                           end
-
-          wall_time_interval_ns = ((current_wall_time - last_wall_time).round(9) * 1e9).to_i
-          @last_wall_time = current_wall_time
+          current_wall_time_ns = get_current_wall_time_timestamp_ns
 
           # Collect backtraces from each thread
-          thread_api.list.each do |thread|
+          threads_to_sample.each do |thread|
             next unless thread.alive?
             next if ignore_thread.is_a?(Proc) && ignore_thread.call(thread)
 
-            event = collect_thread_event(thread, wall_time_interval_ns)
+            event = collect_thread_event(thread, current_wall_time_ns)
             events << event unless event.nil?
           end
 
@@ -111,7 +115,7 @@ module Datadog
           events
         end
 
-        def collect_thread_event(thread, wall_time_interval_ns)
+        def collect_thread_event(thread, current_wall_time_ns)
           locations = thread.backtrace_locations
           return if locations.nil?
 
@@ -123,8 +127,10 @@ module Datadog
           locations = convert_backtrace_locations(locations)
 
           thread_id = thread.respond_to?(:pthread_thread_id) ? thread.pthread_thread_id : thread.object_id
-          trace_id, span_id = get_trace_identifiers(thread)
+          trace_id, span_id, trace_resource = trace_identifiers_helper.trace_identifiers_for(thread)
           cpu_time = get_cpu_time_interval!(thread)
+          wall_time_interval_ns =
+            get_elapsed_since_last_sample_and_set_value(thread, THREAD_LAST_WALL_CLOCK_KEY, current_wall_time_ns)
 
           Events::StackSample.new(
             nil,
@@ -133,6 +139,7 @@ module Datadog
             thread_id,
             trace_id,
             span_id,
+            trace_resource,
             cpu_time,
             wall_time_interval_ns
           )
@@ -152,22 +159,7 @@ module Datadog
           # *before* the thread had time to finish the initialization
           return unless current_cpu_time_ns
 
-          last_cpu_time_ns = (thread[THREAD_LAST_CPU_TIME_KEY] || current_cpu_time_ns)
-          interval = current_cpu_time_ns - last_cpu_time_ns
-
-          # Update CPU time for thread
-          thread[THREAD_LAST_CPU_TIME_KEY] = current_cpu_time_ns
-
-          # Return interval
-          interval
-        end
-
-        def get_trace_identifiers(thread)
-          return unless thread.is_a?(::Thread)
-          return unless Datadog.respond_to?(:tracer) && Datadog.tracer.respond_to?(:active_correlation)
-
-          identifier = Datadog.tracer.active_correlation(thread)
-          [identifier.trace_id, identifier.span_id]
+          get_elapsed_since_last_sample_and_set_value(thread, THREAD_LAST_CPU_TIME_KEY, current_cpu_time_ns)
         end
 
         def compute_wait_time(used_time)
@@ -241,10 +233,10 @@ module Datadog
         end
 
         # If the profiler is started for a while, stopped and then restarted OR whenever the process forks, we need to
-        # clean up the per-thread cpu time counters we keep, so that the first sample after starting doesn't end up with:
+        # clean up any leftover per-thread counters, so that the first sample after starting doesn't end up with:
         #
         # a) negative time: At least on my test docker container, and on the reliability environment, after the process
-        #    forks, the clock reference changes and (old cpu time - new cpu time) can be < 0
+        #    forks, the cpu time reference changes and (old cpu time - new cpu time) can be < 0
         #
         # b) large amount of time: if the profiler was started, then stopped for some amount of time, and then
         #    restarted, we don't want the first sample to be "blamed" for multiple minutes of CPU time
@@ -252,11 +244,58 @@ module Datadog
         # By resetting the last cpu time seen, we start with a clean slate every time we start the stack collector.
         def reset_cpu_time_tracking
           thread_api.list.each do |thread|
-            thread[THREAD_LAST_CPU_TIME_KEY] = nil if thread[THREAD_LAST_CPU_TIME_KEY]
+            # See below for details on why this is needed
+            next if @needs_process_waiter_workaround && thread.is_a?(::Process::Waiter)
+
+            thread.thread_variable_set(THREAD_LAST_CPU_TIME_KEY, nil)
+            thread.thread_variable_set(THREAD_LAST_WALL_CLOCK_KEY, nil)
           end
         end
+
+        def get_elapsed_since_last_sample_and_set_value(thread, key, current_value)
+          # See cthread.rb for more details, but this is a workaround for https://bugs.ruby-lang.org/issues/17807 ;
+          # using all thread_variable related methods on these instances also triggers a crash and for now we just
+          # skip it for the affected Rubies
+          return 0 if @needs_process_waiter_workaround && thread.is_a?(::Process::Waiter)
+
+          last_value = thread.thread_variable_get(key) || current_value
+          thread.thread_variable_set(key, current_value)
+
+          current_value - last_value
+        end
+
+        # Whenever there are more than max_threads_sampled active, we only sample a subset of them.
+        # We do this to avoid impacting the latency of the service being profiled. We want to avoid doing
+        # a big burst of work all at once (sample everything), and instead do a little work each time
+        # (sample a bit by bit).
+        #
+        # Because we pick the threads to sample randomly, we'll eventually sample all threads -- just not at once.
+        # Notice also that this will interact with our dynamic sampling mechanism -- if samples are faster, we take
+        # them more often, if they are slower, we take them less often -- which again means that over a longer period
+        # we should take sample roughly the same samples.
+        #
+        # One downside of this approach is that if there really are many threads, the resulting wall clock times
+        # in a one minute profile may "drift" around the 60 second mark, e.g. maybe we only sampled a thread once per
+        # second and only 59 times, so we'll report 59s, but on the next report we'll include the missing one, so
+        # then the result will be 61s. I've observed 60 +- 1.68 secs for an app with ~65 threads, given the
+        # default maximum of 16 threads. This seems a reasonable enough margin of error given the improvement to
+        # latency (especially on such a large application! -> even bigger latency impact if we tried to sample all
+        # threads).
+        #
+        def threads_to_sample
+          all_threads = thread_api.list
+
+          if all_threads.size > @max_threads_sampled
+            all_threads.sample(@max_threads_sampled)
+          else
+            all_threads
+          end
+        end
+
+        def get_current_wall_time_timestamp_ns
+          Datadog::Utils::Time.get_time(:nanosecond)
+        end
       end
-      # rubocop:enable Metrics/ClassLength
     end
   end
 end

data/lib/ddtrace/profiling/encoding/profile.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'set'
 require 'time'
 
@@ -23,8 +24,16 @@ module Datadog
             flush.event_groups.each { |event_group| template.add_events!(event_group.event_class, event_group.events) }
 
             Datadog.logger.debug do
+              max_events = Datadog.configuration.profiling.advanced.max_events
+              events_sampled =
+                if flush.event_count == max_events
+                  'max events limit hit, events were sampled [profile will be biased], '
+                else
+                  ''
+                end
+
               "Encoding profile covering #{flush.start.iso8601} to #{flush.finish.iso8601}, " \
-              "events: #{flush.event_count} (#{template.debug_statistics})"
+              "events: #{flush.event_count} (#{events_sampled}#{template.debug_statistics})"
             end
 
             # Build the profile and encode it

data/lib/ddtrace/profiling/event.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Profiling
     # Describes a sample of some data obtained from the runtime.

data/lib/ddtrace/profiling/events/stack.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/profiling/event'
 
 module Datadog
@@ -6,12 +7,13 @@ module Datadog
       # Describes a stack profiling event
       class Stack < Event
         attr_reader \
-          :frames,
           :hash,
-          :span_id,
-          :thread_id,
+          :frames,
           :total_frame_count,
-          :trace_id
+          :thread_id,
+          :trace_id,
+          :span_id,
+          :trace_resource
 
         def initialize(
           timestamp,
@@ -19,7 +21,8 @@ module Datadog
           total_frame_count,
           thread_id,
           trace_id,
-          span_id
+          span_id,
+          trace_resource
         )
           super(timestamp)
 
@@ -28,15 +31,16 @@ module Datadog
           @thread_id = thread_id
           @trace_id = trace_id
           @span_id = span_id
+          @trace_resource = trace_resource
 
           @hash = [
             thread_id,
             trace_id,
             span_id,
-            [
-              frames.collect(&:hash),
-              total_frame_count
-            ]
+            # trace_resource is deliberately not included -- events that share the same (trace_id, span_id)
+            # trace_resource might not match between pairs, but they refer to the same trace.
+            frames.collect(&:hash),
+            total_frame_count
           ].hash
         end
       end
@@ -54,6 +58,7 @@ module Datadog
           thread_id,
           trace_id,
           span_id,
+          trace_resource,
           cpu_time_interval_ns,
           wall_time_interval_ns
         )
@@ -63,40 +68,14 @@ module Datadog
             total_frame_count,
             thread_id,
             trace_id,
-            span_id
+            span_id,
+            trace_resource
           )
 
           @cpu_time_interval_ns = cpu_time_interval_ns
           @wall_time_interval_ns = wall_time_interval_ns
         end
       end
-
-      # Describes a stack sample with exception
-      class StackExceptionSample < Stack
-        attr_reader \
-          :exception
-
-        def initialize(
-          timestamp,
-          frames,
-          total_frame_count,
-          thread_id,
-          trace_id,
-          span_id,
-          exception
-        )
-          super(
-            timestamp,
-            frames,
-            total_frame_count,
-            thread_id,
-            trace_id,
-            span_id
-          )
-
-          @exception = exception
-        end
-      end
     end
   end
 end

data/lib/ddtrace/profiling/exporter.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/profiling/transport/io/client'
 
 module Datadog

data/lib/ddtrace/profiling/ext/cpu.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Profiling
     module Ext
@@ -43,9 +44,23 @@ module Datadog
           elsif Gem::Specification.find_all_by_name('rollbar', ROLLBAR_INCOMPATIBLE_VERSIONS).any?
             'You have an incompatible rollbar gem version installed; ensure that you have rollbar >= 3.1.2 by ' \
             "adding `gem 'rollbar', '>= 3.1.2'` to your Gemfile or gems.rb file. " \
-            'See https://github.com/rollbar/rollbar-gem/pull/1018 for details.'
+            'See https://github.com/rollbar/rollbar-gem/pull/1018 for details'
+          elsif Gem::Specification.find_all_by_name('logging').any? && logging_inherit_context_enabled?
+            'The `logging` gem is installed and its thread inherit context feature is enabled. ' \
+            "Please add LOGGING_INHERIT_CONTEXT=false to your application's environment variables to disable the " \
+            'conflicting `logging` gem feature. ' \
+            'See https://github.com/TwP/logging/pull/230 for details'
           end
         end
+
+        private_class_method def self.logging_inherit_context_enabled?
+          # The logging gem provides a mechanism to disable the conflicting behavior, see
+          # https://github.com/TwP/logging/blob/ae9872d093833b2a5a34cbe1faa4e895a81f6845/lib/logging/diagnostic_context.rb#L418
+          # Here we check if the behavior is enabled
+          inherit_context_configuration = ENV['LOGGING_INHERIT_CONTEXT']
+
+          inherit_context_configuration.nil? || !%w[false no 0].include?(inherit_context_configuration.downcase)
+        end
       end
     end
   end

data/lib/ddtrace/profiling/ext/cthread.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'ffi'
 
 module Datadog

data/lib/ddtrace/profiling/ext/forking.rb

@@ -1,3 +1,4 @@
+# typed: false
 module Datadog
   module Profiling
     module Ext

data/lib/ddtrace/profiling/flush.rb

@@ -1,5 +1,6 @@
-require 'ddtrace/runtime/identity'
-require 'ddtrace/runtime/socket'
+# typed: false
+require 'datadog/core/environment/identity'
+require 'datadog/core/environment/socket'
 
 module Datadog
   module Profiling
@@ -23,16 +24,16 @@ module Datadog
     ) do
       def initialize(*args)
         super
-        self.runtime_id = runtime_id || Datadog::Runtime::Identity.id
+        self.runtime_id = runtime_id || Datadog::Core::Environment::Identity.id
         self.service = service || Datadog.configuration.service
         self.env = env || Datadog.configuration.env
         self.version = version || Datadog.configuration.version
-        self.host = host || Datadog::Runtime::Socket.hostname
-        self.language = language || Datadog::Runtime::Identity.lang
-        self.runtime_engine = runtime_engine || Datadog::Runtime::Identity.lang_engine
-        self.runtime_platform = runtime_platform || Datadog::Runtime::Identity.lang_platform
-        self.runtime_version = runtime_version || Datadog::Runtime::Identity.lang_version
-        self.profiler_version = profiler_version || Datadog::Runtime::Identity.tracer_version
+        self.host = host || Datadog::Core::Environment::Socket.hostname
+        self.language = language || Datadog::Core::Environment::Identity.lang
+        self.runtime_engine = runtime_engine || Datadog::Core::Environment::Identity.lang_engine
+        self.runtime_platform = runtime_platform || Datadog::Core::Environment::Identity.lang_platform
+        self.runtime_version = runtime_version || Datadog::Core::Environment::Identity.lang_version
+        self.profiler_version = profiler_version || Datadog::Core::Environment::Identity.tracer_version
         self.tags = tags || Datadog.configuration.tags
       end
     end

data/lib/ddtrace/profiling/native_extension.rb

@@ -0,0 +1,18 @@
+# typed: true
+module Datadog
+  module Profiling
+    # This module contains classes and methods which are implemented using native code in the
+    # ext/ddtrace_profiling_native_extension folder
+    module NativeExtension
+      private_class_method def self.working?
+        native_working?
+      end
+
+      unless singleton_class.private_method_defined?(:native_working?)
+        private_class_method def self.native_working?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/pprof/builder.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require 'ddtrace/profiling/flush'

data/lib/ddtrace/profiling/pprof/converter.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/ext/profiling'
 
 module Datadog
@@ -24,20 +25,19 @@ module Datadog
           # [key, EventGroup]
           event_groups = {}
 
+          # Aggregate each event into a group
+          # with identical properties, but different values.
           events.each do |event|
             key = yield(event)
-            values = build_sample_values(event)
+            values = build_event_values(event)
 
             unless key.nil?
               if event_groups.key?(key)
-                # Update values for group
-                group_values = event_groups[key].values
-                group_values.each_with_index do |group_value, i|
-                  group_values[i] = group_value + values[i]
-                end
+                # Update existing group from event
+                update_group(event_groups[key], event, values)
               else
                 # Add new group
-                event_groups[key] = EventGroup.new(event, values)
+                event_groups[key] = new_group(event, values)
               end
             end
           end
@@ -56,7 +56,7 @@ module Datadog
           index
         end
 
-        def build_sample_values(stack_sample)
+        def build_event_values(event)
           # Build a value array that matches the length of the sample types
           # Populate all values with "no value" by default
           Array.new(@sample_type_mappings.length, Datadog::Ext::Profiling::Pprof::SAMPLE_VALUE_NO_VALUE)
@@ -68,7 +68,7 @@ module Datadog
 
         # Represents a grouped event
         # 'sample' is an example event object from the group.
-        # 'values' is the the summation of the group's sample values
+        # 'values' is the summation of the group's sample values
         EventGroup = Struct.new(:sample, :values)
 
         # Error when the mapping of a sample type to value index is unknown
@@ -83,6 +83,20 @@ module Datadog
             "Mapping for sample value type '#{type}' to index is unknown."
           end
         end
+
+        protected
+
+        def new_group(event, values)
+          EventGroup.new(event, values)
+        end
+
+        def update_group(event_group, event, values)
+          # Update values for group
+          group_values = event_group.values
+          group_values.each_with_index do |group_value, i|
+            group_values[i] = group_value + values[i]
+          end
+        end
       end
     end
   end

data/lib/ddtrace/profiling/pprof/message_set.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/utils/object_set'
 
 module Datadog
@@ -5,7 +6,9 @@ module Datadog
     module Pprof
       # Acts as a unique dictionary of protobuf messages
       class MessageSet < Utils::ObjectSet
-        alias_method :messages, :objects
+        def messages
+          objects
+        end
       end
     end
   end

data/lib/ddtrace/profiling/pprof/payload.rb

@@ -1,10 +1,11 @@
+# typed: true
 module Datadog
   module Profiling
     module Pprof
       # Pprof output data.
       # Includes encoded data and list of types.
       Payload = Struct.new(:data, :types) do
-        def initialize(*args)
+        def initialize(data, types)
           super
           self.types = types || []
         end

data/lib/ddtrace/profiling/pprof/pprof_pb.rb

@@ -1,3 +1,4 @@
+# typed: false
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: lib/ddtrace/profiling/pprof/pprof.proto
 

data/lib/ddtrace/profiling/pprof/stack_sample.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/ext/profiling'
 require 'ddtrace/profiling/events/stack'
 require 'ddtrace/profiling/pprof/builder'
@@ -29,6 +30,7 @@ module Datadog
         def initialize(*_)
           super
 
+          @most_recent_trace_samples = {}
           @processed_unique_stacks = 0
           @processed_with_trace_ids = 0
         end
@@ -39,9 +41,28 @@ module Datadog
         end
 
         def stack_sample_group_key(stack_sample)
+          # We want to make sure we have the most recent sample for any trace.
+          # (This is done here to save an iteration over all samples.)
+          update_most_recent_trace_sample(stack_sample)
+
           stack_sample.hash
         end
 
+        # Track the most recent sample for each trace
+        def update_most_recent_trace_sample(stack_sample)
+          return unless stack_sample.trace_id && stack_sample.trace_resource
+
+          # Update trace resource with most recent value
+          if (most_recent_trace_sample = @most_recent_trace_samples[stack_sample.trace_id])
+            if most_recent_trace_sample.timestamp < stack_sample.timestamp
+              @most_recent_trace_samples[stack_sample.trace_id] = stack_sample
+            end
+          else
+            # Add trace resource
+            @most_recent_trace_samples[stack_sample.trace_id] = stack_sample
+          end
+        end
+
         def build_samples(stack_samples)
           groups = group_events(stack_samples, &method(:stack_sample_group_key))
           groups.collect do |_group_key, group|
@@ -63,7 +84,7 @@ module Datadog
           )
         end
 
-        def build_sample_values(stack_sample)
+        def build_event_values(stack_sample)
           no_value = Datadog::Ext::Profiling::Pprof::SAMPLE_VALUE_NO_VALUE
           values = super(stack_sample)
           values[sample_value_index(:cpu_time_ns)] = stack_sample.cpu_time_interval_ns || no_value
@@ -79,19 +100,35 @@ module Datadog
             )
           ]
 
-          unless stack_sample.trace_id.nil? || stack_sample.trace_id.zero?
+          trace_id = stack_sample.trace_id || 0
+          span_id = stack_sample.span_id || 0
+
+          if trace_id != 0 && span_id != 0
             @processed_with_trace_ids += 1
+
             labels << Perftools::Profiles::Label.new(
               key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_TRACE_ID),
-              str: builder.string_table.fetch(stack_sample.trace_id.to_s)
+              str: builder.string_table.fetch(trace_id.to_s)
             )
-          end
 
-          unless stack_sample.span_id.nil? || stack_sample.span_id.zero?
             labels << Perftools::Profiles::Label.new(
               key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_SPAN_ID),
-              str: builder.string_table.fetch(stack_sample.span_id.to_s)
+              str: builder.string_table.fetch(span_id.to_s)
             )
+
+            # Use most up-to-date trace resource, if available.
+            # Otherwise, use the trace resource provided.
+            trace_resource = (
+              @most_recent_trace_samples[stack_sample.trace_id] \
+              || stack_sample
+            ).trace_resource
+
+            if trace_resource && !trace_resource.empty?
+              labels << Perftools::Profiles::Label.new(
+                key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_TRACE_ENDPOINT),
+                str: builder.string_table.fetch(trace_resource)
+              )
+            end
           end
 
           labels

data/lib/ddtrace/profiling/pprof/string_table.rb

@@ -1,3 +1,4 @@
+# typed: strict
 require 'ddtrace/utils/string_table'
 
 module Datadog

data/lib/ddtrace/profiling/pprof/template.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/profiling/pprof/payload'
 require 'ddtrace/profiling/pprof/message_set'
 require 'ddtrace/profiling/pprof/builder'

data/lib/ddtrace/profiling/preload.rb

@@ -1,3 +1,4 @@
+# typed: strict
 require 'ddtrace'
 
 Datadog.profiler.start if Datadog.profiler