ddtrace 0.33.1 → 0.34.0

data/lib/ddtrace/correlation.rb

@@ -1,27 +1,34 @@
+require 'ddtrace/ext/correlation'
+require 'ddtrace/environment'
+
 module Datadog
   # Contains behavior for managing correlations with tracing
   # e.g. Retrieve a correlation to the current trace for logging, etc.
   module Correlation
     # Struct representing correlation
-    Identifier = Struct.new(:trace_id, :span_id) do
+    Identifier = Struct.new(:trace_id, :span_id, :env, :version) do
       def initialize(*args)
         super
         self.trace_id = trace_id || 0
         self.span_id = span_id || 0
+        self.env = env || Datadog.configuration.env
+        self.version = version || Datadog.configuration.version
       end
 
       def to_s
-        "dd.trace_id=#{trace_id} dd.span_id=#{span_id}"
+        str =  "#{Ext::Correlation::ATTR_TRACE_ID}=#{trace_id}"
+        str += " #{Ext::Correlation::ATTR_SPAN_ID}=#{span_id}"
+        str += " #{Ext::Correlation::ATTR_ENV}=#{env}"
+        str += " #{Ext::Correlation::ATTR_VERSION}=#{version}"
+        str
       end
     end.freeze
 
-    NULL_IDENTIFIER = Identifier.new.freeze
-
     module_function
 
     # Produces a CorrelationIdentifier from the Context provided
     def identifier_from_context(context)
-      return NULL_IDENTIFIER if context.nil?
+      return Identifier.new.freeze if context.nil?
       Identifier.new(context.trace_id, context.span_id).freeze
     end
   end

data/lib/ddtrace/environment.rb

@@ -1,3 +1,5 @@
+require 'ddtrace/ext/environment'
+
 module Datadog
   # Namespace for handling application environment
   module Environment
@@ -19,5 +21,7 @@ module Datadog
         end
       end
     end
+
+    extend Helpers
   end
 end

data/lib/ddtrace/event.rb

@@ -0,0 +1,52 @@
+require 'ddtrace/logger'
+
+module Datadog
+  # A simple pub-sub event model for components to exchange messages through.
+  class Event
+    attr_reader \
+      :name,
+      :subscriptions
+
+    def initialize(name)
+      @name = name
+      @subscriptions = {}
+      @mutex = Mutex.new
+    end
+
+    def subscribe(key, &block)
+      raise ArgumentError, 'Must give a block to subscribe!' unless block
+
+      @mutex.synchronize do
+        subscriptions[key] = block
+      end
+    end
+
+    def unsubscribe(key)
+      @mutex.synchronize do
+        subscriptions.delete(key)
+      end
+    end
+
+    def unsubscribe_all!
+      @mutex.synchronize do
+        subscriptions.clear
+      end
+
+      true
+    end
+
+    def publish(*args)
+      @mutex.synchronize do
+        subscriptions.each do |key, block|
+          begin
+            block.call(*args)
+          rescue StandardError => e
+            Datadog::Logger.log.debug("Error while handling '#{key}' for '#{name}' event: #{e.message}")
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/analytics.rb

@@ -5,6 +5,7 @@ module Datadog
       DEFAULT_SAMPLE_RATE = 1.0
       ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'.freeze
       TAG_ENABLED = 'analytics.enabled'.freeze
+      TAG_MEASURED = '_dd.measured'.freeze
       TAG_SAMPLE_RATE = '_dd1.sr.eausr'.freeze
     end
   end

data/lib/ddtrace/ext/correlation.rb

@@ -0,0 +1,10 @@
+module Datadog
+  module Ext
+    module Correlation
+      ATTR_ENV = 'dd.env'.freeze
+      ATTR_SPAN_ID = 'dd.span_id'.freeze
+      ATTR_TRACE_ID = 'dd.trace_id'.freeze
+      ATTR_VERSION = 'dd.version'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/environment.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module Ext
+    module Environment
+      ENV_ENVIRONMENT = 'DD_ENV'.freeze
+      ENV_SERVICE = 'DD_SERVICE'.freeze
+      ENV_TAGS = 'DD_TAGS'.freeze
+      ENV_VERSION = 'DD_VERSION'.freeze
+
+      TAG_ENV = 'env'.freeze
+      TAG_VERSION = 'version'.freeze
+    end
+  end
+end

data/lib/ddtrace/metrics.rb

@@ -2,6 +2,7 @@ require 'ddtrace/ext/metrics'
 
 require 'set'
 require 'logger'
+require 'ddtrace/environment'
 require 'ddtrace/utils/time'
 require 'ddtrace/runtime/identity'
 
@@ -151,6 +152,12 @@ module Datadog
         # and defaults are unfrozen for mutation in Statsd.
         DEFAULT.dup.tap do |options|
           options[:tags] = options[:tags].dup
+
+          env = Datadog.configuration.env
+          options[:tags] << "#{Datadog::Ext::Environment::TAG_ENV}:#{env}" unless env.nil?
+
+          version = Datadog.configuration.version
+          options[:tags] << "#{Datadog::Ext::Environment::TAG_VERSION}:#{version}" unless version.nil?
         end
       end
     end

data/lib/ddtrace/opentelemetry/extensions.rb

@@ -0,0 +1,13 @@
+require 'ddtrace/span'
+require 'ddtrace/opentelemetry/span'
+
+module Datadog
+  module OpenTelemetry
+    # Defines extensions to ddtrace for OpenTelemetry support
+    module Extensions
+      def self.extended(base)
+        Datadog::Span.send(:prepend, OpenTelemetry::Span)
+      end
+    end
+  end
+end

data/lib/ddtrace/opentelemetry/span.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/ext/environment'
+
+module Datadog
+  module OpenTelemetry
+    # Extensions for Datadog::Span
+    module Span
+      TAG_SERVICE_NAME = 'service.name'.freeze
+      TAG_SERVICE_VERSION = 'service.version'.freeze
+
+      def set_tag(key, value)
+        # Configure sampling priority if they give us a forced tracing tag
+        # DEV: Do not set if the value they give us is explicitly "false"
+        case key
+        when TAG_SERVICE_NAME
+          if defined?(super)
+            # Set original tag and Datadog version tag
+            self.service = value
+            super
+          end
+        when TAG_SERVICE_VERSION
+          if defined?(super)
+            # Set original tag and Datadog version tag
+            super
+            super(Datadog::Ext::Environment::TAG_VERSION, value)
+          end
+        else
+          # Otherwise, set the tag normally.
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/span.rb

@@ -4,6 +4,7 @@ require 'thread'
 require 'ddtrace/utils'
 require 'ddtrace/ext/errors'
 require 'ddtrace/ext/priority'
+require 'ddtrace/environment'
 require 'ddtrace/analytics'
 require 'ddtrace/forced_tracing'
 require 'ddtrace/diagnostics/health'
@@ -172,7 +173,7 @@ module Datadog
       # spans without a service would be dropped, so here we provide a default.
       # This should really never happen with integrations in contrib, as a default
       # service is always set. It's only for custom instrumentation.
-      @service ||= @tracer.default_service unless @tracer.nil?
+      @service ||= (Datadog.configuration.service || (@tracer && @tracer.default_service))
 
       begin
         @context.close_span(self)

data/lib/ddtrace/tracer.rb

@@ -3,6 +3,7 @@ require 'thread'
 require 'logger'
 require 'pathname'
 
+require 'ddtrace/environment'
 require 'ddtrace/span'
 require 'ddtrace/context'
 require 'ddtrace/logger'
@@ -83,7 +84,7 @@ module Datadog
                        end
 
       @mutex = Mutex.new
-      @tags = {}
+      @tags = options.fetch(:tags, Datadog.configuration.tags)
 
       # Enable priority sampling by default
       activate_priority_sampling!(@sampler)
@@ -154,7 +155,8 @@ module Datadog
     #
     #   tracer.set_tags('env' => 'prod', 'component' => 'core')
     def set_tags(tags)
-      @tags.update(tags)
+      string_tags = Hash[tags.collect { |k, v| [k.to_s, v] }]
+      @tags = @tags.merge(string_tags)
     end
 
     # Guess context and parent from child_of entry.
@@ -206,8 +208,8 @@ module Datadog
         # child span
         span.parent = parent # sets service, trace_id, parent_id, sampled
       end
-      tags.each { |k, v| span.set_tag(k, v) } unless tags.empty?
       @tags.each { |k, v| span.set_tag(k, v) } unless @tags.empty?
+      tags.each { |k, v| span.set_tag(k, v) } unless tags.empty?
       span.start_time = start_time
 
       # this could at some point be optional (start_active_span vs start_manual_span)
@@ -392,6 +394,14 @@ module Datadog
 
       writer_options[:transport_options] = transport_options
 
+      # ensure any configuration to runtime_metrics statsd client is
+      # passed on when writer gets rebuilt
+      unless writer_options.key?(:runtime_metrics)
+        if @writer && !@writer.runtime_metrics.nil?
+          writer_options[:runtime_metrics] = @writer.runtime_metrics
+        end
+      end
+
       if rebuild_writer || writer
         # Make sure old writer is shut down before throwing away.
         # Don't want additional threads running...

data/lib/ddtrace/version.rb

@@ -1,8 +1,8 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 33
-    PATCH = 1
+    MINOR = 34
+    PATCH = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')

data/lib/ddtrace/worker.rb

@@ -0,0 +1,20 @@
+module Datadog
+  # Base class for work tasks
+  class Worker
+    attr_reader \
+      :task
+
+    def initialize(&block)
+      @task = block
+    end
+
+    def perform(*args)
+      task.call(*args) unless task.nil?
+    end
+
+    protected
+
+    attr_writer \
+      :task
+  end
+end

data/lib/ddtrace/workers/async.rb

@@ -0,0 +1,165 @@
+require 'ddtrace/logger'
+
+module Datadog
+  module Workers
+    module Async
+      # Adds threading behavior to workers
+      # to run tasks asynchronously.
+      # rubocop:disable Metrics/ModuleLength
+      module Thread
+        FORK_POLICY_STOP = :stop
+        FORK_POLICY_RESTART = :restart
+        SHUTDOWN_TIMEOUT = 1
+
+        def self.included(base)
+          base.send(:prepend, PrependedMethods)
+        end
+
+        # Methods that must be prepended
+        module PrependedMethods
+          def perform(*args)
+            start { self.result = super(*args) } unless started?
+          end
+        end
+
+        attr_reader \
+          :error,
+          :result
+
+        attr_writer \
+          :fork_policy
+
+        def join(timeout = nil)
+          return true unless running?
+          !worker.join(timeout).nil?
+        end
+
+        def terminate
+          return false unless running?
+          @run_async = false
+          worker.terminate
+          true
+        end
+
+        def run_async?
+          @run_async = false unless instance_variable_defined?(:@run_async)
+          @run_async == true
+        end
+
+        def started?
+          !(worker.nil? || forked?)
+        end
+
+        def running?
+          !worker.nil? && worker.alive?
+        end
+
+        def error?
+          @error = nil unless instance_variable_defined?(:@error)
+          !@error.nil?
+        end
+
+        def completed?
+          !worker.nil? && worker.status == false && !error?
+        end
+
+        def failed?
+          !worker.nil? && worker.status.nil?
+        end
+
+        def forked?
+          !pid.nil? && pid != Process.pid
+        end
+
+        def fork_policy
+          @fork_policy ||= FORK_POLICY_STOP
+        end
+
+        protected
+
+        attr_writer \
+          :result
+
+        def mutex
+          @mutex ||= Mutex.new
+        end
+
+        def after_fork
+          # Do nothing by default
+        end
+
+        private
+
+        attr_reader \
+          :pid
+
+        def mutex_after_fork
+          @mutex_after_fork ||= Mutex.new
+        end
+
+        def worker
+          @worker ||= nil
+        end
+
+        def start(&block)
+          mutex.synchronize do
+            return if running?
+            if forked?
+              case fork_policy
+              when FORK_POLICY_STOP
+                stop_fork
+              when FORK_POLICY_RESTART
+                restart_after_fork(&block)
+              end
+            elsif !run_async?
+              start_worker(&block)
+            end
+          end
+        end
+
+        def start_worker
+          @run_async = true
+          @pid = Process.pid
+          @error = nil
+          Logger.log.debug("Starting thread in the process: #{Process.pid}")
+
+          @worker = ::Thread.new do
+            begin
+              yield
+            # rubocop:disable Lint/RescueException
+            rescue Exception => e
+              @error = e
+              Logger.log.debug("Worker thread error. Cause #{e.message} Location: #{e.backtrace.first}")
+              raise
+            end
+          end
+        end
+
+        def stop_fork
+          mutex_after_fork.synchronize do
+            if forked?
+              # Trigger callback to allow workers to reset themselves accordingly
+              after_fork
+
+              # Reset and turn off
+              @pid = Process.pid
+              @run_async = false
+            end
+          end
+        end
+
+        def restart_after_fork(&block)
+          mutex_after_fork.synchronize do
+            if forked?
+              # Trigger callback to allow workers to reset themselves accordingly
+              after_fork
+
+              # Start worker
+              start_worker(&block)
+            end
+          end
+        end
+      end
+    end
+  end
+end