ls-trace 0.1.2 → 0.2.0

data/lib/ddtrace/diagnostics/health.rb

@@ -10,20 +10,23 @@ module Datadog
         count :api_errors, Ext::Diagnostics::Health::Metrics::METRIC_API_ERRORS
         count :api_requests, Ext::Diagnostics::Health::Metrics::METRIC_API_REQUESTS
         count :api_responses, Ext::Diagnostics::Health::Metrics::METRIC_API_RESPONSES
+        count :error_context_overflow, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_CONTEXT_OVERFLOW
+        count :error_instrumentation_patch, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_INSTRUMENTATION_PATCH
+        count :error_span_finish, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_SPAN_FINISH
+        count :error_unfinished_spans, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_UNFINISHED_SPANS
+        count :instrumentation_patched, Ext::Diagnostics::Health::Metrics::METRIC_INSTRUMENTATION_PATCHED
         count :queue_accepted, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_ACCEPTED
         count :queue_accepted_lengths, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_ACCEPTED_LENGTHS
         count :queue_dropped, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_DROPPED
-        gauge :queue_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_LENGTH
-        gauge :queue_max_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_MAX_LENGTH
-        gauge :queue_spans, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_SPANS
         count :traces_filtered, Ext::Diagnostics::Health::Metrics::METRIC_TRACES_FILTERED
+        count :transport_trace_too_large, Ext::Diagnostics::Health::Metrics::METRIC_TRANSPORT_TRACE_TOO_LARGE
+        count :transport_chunked, Ext::Diagnostics::Health::Metrics::METRIC_TRANSPORT_CHUNKED
         count :writer_cpu_time, Ext::Diagnostics::Health::Metrics::METRIC_WRITER_CPU_TIME
-      end
 
-      module_function
-
-      def metrics
-        Datadog.configuration.diagnostics.health_metrics
+        gauge :queue_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_LENGTH
+        gauge :queue_max_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_MAX_LENGTH
+        gauge :queue_spans, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_SPANS
+        gauge :sampling_service_cache_length, Ext::Diagnostics::Health::Metrics::METRIC_SAMPLING_SERVICE_CACHE_LENGTH
       end
     end
   end

data/lib/ddtrace/encoding.rb

@@ -10,19 +10,12 @@ module Datadog
         raise NotImplementedError
       end
 
-      # Encodes a list of traces, expecting a list of items where each items
-      # is a list of spans. Before dump the string in a serialized format all
-      # traces are normalized. The traces nesting is not changed.
-      def encode_traces(traces)
-        to_send = []
-        traces.each do |trace|
-          to_send << trace.map(&:to_hash)
-        end
-        encode(to_send)
+      # Concatenates a list of elements previously encoded by +#encode+.
+      def join(encoded_elements)
+        raise NotImplementedError
       end
 
-      # Defines the underlying format used during traces or services encoding.
-      # This method must be implemented and should only be used by the internal functions.
+      # Serializes a single trace into a String suitable for network transmission.
       def encode(_)
         raise NotImplementedError
       end
@@ -43,6 +36,10 @@ module Datadog
       def encode(obj)
         JSON.dump(obj)
       end
+
+      def join(encoded_data)
+        "[#{encoded_data.join(',')}]"
+      end
     end
 
     # Encoder for the Msgpack format
@@ -60,6 +57,13 @@ module Datadog
       def encode(obj)
         MessagePack.pack(obj)
       end
+
+      def join(encoded_data)
+        packer = MessagePack::Packer.new
+        packer.write_array_header(encoded_data.size)
+
+        (packer.buffer.to_a + encoded_data).join
+      end
     end
   end
 end

data/lib/ddtrace/environment.rb

@@ -1,23 +1,41 @@
+require 'ddtrace/ext/environment'
+
 module Datadog
   # Namespace for handling application environment
   module Environment
     # Defines helper methods for environment
     module Helpers
       def env_to_bool(var, default = nil)
-        ENV.key?(var) ? ENV[var].to_s.downcase == 'true' : default
+        var = decode_array(var)
+        var && ENV.key?(var) ? ENV[var].to_s.strip.downcase == 'true' : default
+      end
+
+      def env_to_int(var, default = nil)
+        var = decode_array(var)
+        var && ENV.key?(var) ? ENV[var].to_i : default
       end
 
       def env_to_float(var, default = nil)
-        ENV.key?(var) ? ENV[var].to_f : default
+        var = decode_array(var)
+        var && ENV.key?(var) ? ENV[var].to_f : default
       end
 
       def env_to_list(var, default = [])
-        if ENV.key?(var)
+        var = decode_array(var)
+        if var && ENV.key?(var)
           ENV[var].split(',').map(&:strip)
         else
           default
         end
       end
+
+      private
+
+      def decode_array(var)
+        var.is_a?(Array) ? var.find { |env_var| ENV.key?(env_var) } : var
+      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.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,11 @@
+module Datadog
+  module Ext
+    module Correlation
+      ATTR_ENV = 'dd.env'.freeze
+      ATTR_SERVICE = 'dd.service'.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/diagnostics.rb

@@ -1,6 +1,9 @@
 module Datadog
   module Ext
     module Diagnostics
+      DD_TRACE_STARTUP_LOGS = 'DD_TRACE_STARTUP_LOGS'.freeze
+      DD_TRACE_DEBUG = 'DD_TRACE_DEBUG'.freeze
+      DD_TRACE_ENABLED = 'DD_TRACE_ENABLED'.freeze
       # Health
       module Health
         # Metrics
@@ -10,13 +13,21 @@ module Datadog
           METRIC_API_ERRORS = 'datadog.tracer.api.errors'.freeze
           METRIC_API_REQUESTS = 'datadog.tracer.api.requests'.freeze
           METRIC_API_RESPONSES = 'datadog.tracer.api.responses'.freeze
+          METRIC_ERROR_CONTEXT_OVERFLOW = 'datadog.tracer.error.context_overflow'.freeze
+          METRIC_ERROR_INSTRUMENTATION_PATCH = 'datadog.tracer.error.instrumentation_patch'.freeze
+          METRIC_ERROR_SPAN_FINISH = 'datadog.tracer.error.span_finish'.freeze
+          METRIC_ERROR_UNFINISHED_SPANS = 'datadog.tracer.error.unfinished_spans'.freeze
+          METRIC_INSTRUMENTATION_PATCHED = 'datadog.tracer.instrumentation_patched'.freeze
           METRIC_QUEUE_ACCEPTED = 'datadog.tracer.queue.accepted'.freeze
           METRIC_QUEUE_ACCEPTED_LENGTHS = 'datadog.tracer.queue.accepted_lengths'.freeze
           METRIC_QUEUE_DROPPED = 'datadog.tracer.queue.dropped'.freeze
           METRIC_QUEUE_LENGTH = 'datadog.tracer.queue.length'.freeze
           METRIC_QUEUE_MAX_LENGTH = 'datadog.tracer.queue.max_length'.freeze
           METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'.freeze
+          METRIC_SAMPLING_SERVICE_CACHE_LENGTH = 'datadog.tracer.sampling.service_cache_length'.freeze
           METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'.freeze
+          METRIC_TRANSPORT_CHUNKED = 'datadog.tracer.transport.chunked'.freeze
+          METRIC_TRANSPORT_TRACE_TOO_LARGE = 'datadog.tracer.transport.trace_too_large'.freeze
           METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
         end
       end

data/lib/ddtrace/ext/environment.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Ext
+    module Environment
+      ENV_API_KEY = 'DD_API_KEY'.freeze
+      ENV_ENVIRONMENT = 'DD_ENV'.freeze
+      ENV_SERVICE = 'DD_SERVICE'.freeze
+      ENV_SITE = 'DD_SITE'.freeze
+      ENV_TAGS = 'DD_TAGS'.freeze
+      ENV_VERSION = 'DD_VERSION'.freeze
+
+      TAG_ENV = 'env'.freeze
+      TAG_SERVICE = 'service'.freeze
+      TAG_VERSION = 'version'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/forced_tracing.rb

@@ -12,7 +12,7 @@ module Datadog
 
         # Only log each deprecation warning once (safeguard against log spam)
         unless @deprecation_warning_shown
-          Datadog::Tracer.log.warn(
+          Datadog.logger.warn(
             'forced tracing: Datadog::Ext::ForcedTracing has been renamed to Datadog::Ext::ManualTracing'
           )
           @deprecation_warning_shown = true

data/lib/ddtrace/ext/sampling.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Ext
+    module Sampling
+      ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'.freeze
+      ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'.freeze
+
+      # If rule sampling is applied to a span, set this metric the sample rate configured for that rule.
+      # This should be done regardless of sampling outcome.
+      RULE_SAMPLE_RATE = '_dd.rule_psr'.freeze
+
+      # If rate limiting is checked on a span, set this metric the effective rate limiting rate applied.
+      # This should be done regardless of rate limiting outcome.
+      RATE_LIMITER_RATE = '_dd.limit_psr'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/transport.rb

@@ -6,6 +6,7 @@ module Datadog
         DEFAULT_PORT = 8126
         ENV_DEFAULT_HOST = 'DD_AGENT_HOST'.freeze
         ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'.freeze
+        ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'.freeze
         HEADER_CONTAINER_ID = 'Datadog-Container-ID'.freeze
         HEADER_META_LANG = 'Datadog-Meta-Lang'.freeze
         HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'.freeze

data/lib/ddtrace/logger.rb

@@ -1,15 +1,16 @@
 require 'logger'
 
 module Datadog
-  LOG_PREFIX = 'ddtrace'.freeze
-
   # A custom logger with minor enhancements:
   # - progname defaults to ddtrace to clearly identify Datadog dd-trace-rb related messages
   # - adds last caller stack-trace info to know where the message comes from
   class Logger < ::Logger
+    PREFIX = 'ddtrace'.freeze
+
     def initialize(*args, &block)
       super
-      self.progname = LOG_PREFIX
+      self.progname = PREFIX
+      self.level = ::Logger::INFO
     end
 
     def add(severity, message = nil, progname = nil, &block)

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'
 
@@ -62,7 +63,7 @@ module Datadog
 
       statsd.count(stat, value, metric_options(options))
     rescue StandardError => e
-      Datadog::Tracer.log.error("Failed to send count stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.error("Failed to send count stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def distribution(stat, value = nil, options = nil, &block)
@@ -72,7 +73,7 @@ module Datadog
 
       statsd.distribution(stat, value, metric_options(options))
     rescue StandardError => e
-      Datadog::Tracer.log.error("Failed to send distribution stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.error("Failed to send distribution stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def increment(stat, options = nil)
@@ -81,7 +82,7 @@ module Datadog
 
       statsd.increment(stat, metric_options(options))
     rescue StandardError => e
-      Datadog::Tracer.log.error("Failed to send increment stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.error("Failed to send increment stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def gauge(stat, value = nil, options = nil, &block)
@@ -91,7 +92,7 @@ module Datadog
 
       statsd.gauge(stat, value, metric_options(options))
     rescue StandardError => e
-      Datadog::Tracer.log.error("Failed to send gauge stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.error("Failed to send gauge stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def time(stat, options = nil)
@@ -107,7 +108,7 @@ module Datadog
           distribution(stat, ((finished - start) * 1000), options)
         end
       rescue StandardError => e
-        Datadog::Tracer.log.error("Failed to send time stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+        Datadog.logger.error("Failed to send time stat. Cause: #{e.message} Source: #{e.backtrace.first}")
       end
     end
 
@@ -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/monkey.rb

@@ -48,7 +48,7 @@ module Datadog
     end
 
     def log_deprecation_warning(method)
-      Datadog::Tracer.log.warn("#{method}:#{DEPRECATION_WARNING}")
+      Datadog.logger.warn("#{method}:#{DEPRECATION_WARNING}")
     end
 
     class << self

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/opentracer/global_tracer.rb

@@ -6,7 +6,7 @@ module Datadog
         super.tap do
           if tracer.class <= Datadog::OpenTracer::Tracer
             # Update the Datadog global tracer, too.
-            Datadog.configuration.tracer = tracer.datadog_tracer
+            Datadog.configure { |c| c.tracer = tracer.datadog_tracer }
           end
         end
       end

data/lib/ddtrace/pin.rb

@@ -12,26 +12,36 @@ module Datadog
       obj.datadog_pin
     end
 
-    attr_reader :service_name
     attr_accessor :app
-    attr_accessor :tags
     attr_accessor :app_type
-    attr_accessor :name
-    attr_accessor :tracer
     attr_accessor :config
+    attr_accessor :name
+    attr_accessor :service_name
+    attr_accessor :tags
+    attr_reader :tracer
+    attr_accessor :writer
+
+    alias service= service_name=
+    alias service service_name
 
     def initialize(service_name, options = {})
+      deprecation_warning unless options[:tracer].is_a?(Proc) || options[:tracer].nil?
+
       @app = options[:app]
-      @tags = options[:tags]
       @app_type = options[:app_type]
-      @name = nil # this would rarely be overriden as it's really span-specific
-      @tracer = options[:tracer] || Datadog.tracer
       @config = options[:config]
-      self.service_name = service_name
+      @name = nil # this would rarely be overriden as it's really span-specific
+      @service_name = service_name
+      @tags = options[:tags]
+      @tracer = options[:tracer]
+    end
+
+    def tracer
+      @tracer.is_a?(Proc) ? @tracer.call : (@tracer || Datadog.tracer)
     end
 
     def enabled?
-      return @tracer.enabled if @tracer
+      return tracer.enabled if tracer
       false
     end
 
@@ -56,15 +66,29 @@ module Datadog
       obj.datadog_pin = self
     end
 
-    def service_name=(name)
-      @service_name = name
+    def to_s
+      "Pin(service:#{service},app:#{app},app_type:#{app_type},name:#{name})"
+    end
+
+    private
+
+    DEPRECATION_WARNING = %(
+      Explicitly providing a tracer instance is DEPRECATED.
+      It's recommended to not provide an explicit tracer instance
+      and let Datadog::Pin resolve the correct tracer internally.
+      ).freeze
+
+    def deprecation_warning
+      log_deprecation_warning('Datadog::Pin.new')
     end
 
-    alias service= service_name=
-    alias service service_name
+    include Datadog::Patcher
 
-    def to_s
-      "Pin(service:#{service},app:#{app},app_type:#{app_type},name:#{name})"
+    def log_deprecation_warning(method_name)
+      # Only log each deprecation warning once (safeguard against log spam)
+      do_once(method_name) do
+        Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
+      end
     end
   end
 
@@ -107,7 +131,7 @@ module Datadog
     def log_deprecation_warning(method_name)
       # Only log each deprecation warning once (safeguard against log spam)
       do_once(method_name) do
-        Datadog::Tracer.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
+        Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
       end
     end
   end