ddtrace 0.38.0

data/lib/ddtrace/diagnostics/health.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/ext/diagnostics'
+require 'ddtrace/metrics'
+
+module Datadog
+  module Diagnostics
+    # Health-related diagnostics
+    module Health
+      # Health metrics for diagnostics
+      class Metrics < ::Datadog::Metrics
+        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
+        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
+
+        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
+end

data/lib/ddtrace/distributed_tracing/headers/b3.rb

@@ -0,0 +1,44 @@
+require 'ddtrace/ext/distributed'
+require 'ddtrace/distributed_tracing/headers/headers'
+require 'ddtrace/distributed_tracing/headers/helpers'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # B3 provides helpers to inject or extract headers for B3 style headers
+      module B3
+        include Ext::DistributedTracing
+
+        def self.inject!(context, env)
+          return if context.nil?
+
+          # DEV: We need these to be hex encoded
+          env[B3_HEADER_TRACE_ID] = context.trace_id.to_s(16)
+          env[B3_HEADER_SPAN_ID] = context.span_id.to_s(16)
+
+          unless context.sampling_priority.nil?
+            sampling_priority = DistributedTracing::Headers::Helpers.clamp_sampling_priority(context.sampling_priority)
+            env[B3_HEADER_SAMPLED] = sampling_priority.to_s
+          end
+        end
+
+        def self.extract(env)
+          # Extract values from headers
+          # DEV: B3 doesn't have "origin"
+          headers = Headers.new(env)
+          trace_id = headers.id(B3_HEADER_TRACE_ID, 16)
+          span_id = headers.id(B3_HEADER_SPAN_ID, 16)
+          # We don't need to try and convert sampled since B3 supports 0/1 (AUTO_REJECT/AUTO_KEEP)
+          sampling_priority = headers.number(B3_HEADER_SAMPLED)
+
+          # Return early if this propagation is not valid
+          return unless trace_id && span_id
+
+          ::Datadog::Context.new(trace_id: trace_id,
+                                 span_id: span_id,
+                                 sampling_priority: sampling_priority)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/distributed_tracing/headers/b3_single.rb

@@ -0,0 +1,56 @@
+require 'ddtrace/ext/distributed'
+require 'ddtrace/distributed_tracing/headers/headers'
+require 'ddtrace/distributed_tracing/headers/helpers'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # B3Single provides helpers to inject or extract headers for B3 single header style headers
+      module B3Single
+        include Ext::DistributedTracing
+
+        def self.inject!(context, env)
+          return if context.nil?
+
+          # Header format:
+          #   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
+          # https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
+          # DEV: `{SamplingState}` and `{ParentSpanId`}` are optional
+
+          # DEV: We need these to be hex encoded
+          header = "#{context.trace_id.to_s(16)}-#{context.span_id.to_s(16)}"
+
+          unless context.sampling_priority.nil?
+            sampling_priority = DistributedTracing::Headers::Helpers.clamp_sampling_priority(context.sampling_priority)
+            header += "-#{sampling_priority}"
+          end
+
+          env[B3_HEADER_SINGLE] = header
+        end
+
+        def self.extract(env)
+          # Header format:
+          #   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
+          # https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
+          # DEV: `{SamplingState}` and `{ParentSpanId`}` are optional
+
+          headers = Headers.new(env)
+          value = headers.header(B3_HEADER_SINGLE)
+          return if value.nil?
+
+          parts = value.split('-')
+          trace_id = headers.value_to_id(parts[0], 16) unless parts.empty?
+          span_id = headers.value_to_id(parts[1], 16) if parts.length > 1
+          sampling_priority = headers.value_to_number(parts[2]) if parts.length > 2
+
+          # Return early if this propagation is not valid
+          return unless trace_id && span_id
+
+          ::Datadog::Context.new(trace_id: trace_id,
+                                 span_id: span_id,
+                                 sampling_priority: sampling_priority)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/distributed_tracing/headers/datadog.rb

@@ -0,0 +1,42 @@
+require 'ddtrace/ext/distributed'
+require 'ddtrace/distributed_tracing/headers/headers'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # Datadog provides helpers to inject or extract headers for Datadog style headers
+      module Datadog
+        include Ext::DistributedTracing
+
+        def self.inject!(context, env)
+          return if context.nil?
+
+          env[HTTP_HEADER_TRACE_ID] = context.trace_id.to_s
+          env[HTTP_HEADER_PARENT_ID] = context.span_id.to_s
+          env[HTTP_HEADER_SAMPLING_PRIORITY] = context.sampling_priority.to_s unless context.sampling_priority.nil?
+          env[HTTP_HEADER_ORIGIN] = context.origin.to_s unless context.origin.nil?
+        end
+
+        def self.extract(env)
+          # Extract values from headers
+          headers = Headers.new(env)
+          trace_id = headers.id(HTTP_HEADER_TRACE_ID)
+          parent_id = headers.id(HTTP_HEADER_PARENT_ID)
+          origin = headers.header(HTTP_HEADER_ORIGIN)
+          sampling_priority = headers.number(HTTP_HEADER_SAMPLING_PRIORITY)
+
+          # Return early if this propagation is not valid
+          # DEV: To be valid we need to have a trace id and a parent id or when it is a synthetics trace, just the trace id
+          # DEV: `DistributedHeaders#id` will not return 0
+          return unless (trace_id && parent_id) || (origin && trace_id)
+
+          # Return new context
+          ::Datadog::Context.new(trace_id: trace_id,
+                                 span_id: parent_id,
+                                 origin: origin,
+                                 sampling_priority: sampling_priority)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/distributed_tracing/headers/headers.rb

@@ -0,0 +1,70 @@
+require 'ddtrace/configuration'
+require 'ddtrace/span'
+require 'ddtrace/ext/distributed'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # Headers provides easy access and validation methods for Rack headers
+      class Headers
+        include Ext::DistributedTracing
+
+        def initialize(env)
+          @env = env
+        end
+
+        # TODO: Don't assume Rack format.
+        #       Make distributed tracing headers apathetic.
+        def header(name)
+          rack_header = "http-#{name}".upcase!.tr('-', '_')
+
+          hdr = @env[rack_header]
+
+          # Only return the value if it is not an empty string
+          hdr if hdr != ''
+        end
+
+        def id(hdr, base = 10)
+          value_to_id(header(hdr), base)
+        end
+
+        def value_to_id(value, base = 10)
+          id = value_to_number(value, base)
+
+          # Return early if we could not parse a number
+          return if id.nil?
+
+          # Zero or greater than max allowed value of 2**64
+          return if id.zero? || id > Span::EXTERNAL_MAX_ID
+          id < 0 ? id + (2**64) : id
+        end
+
+        def number(hdr, base = 10)
+          value_to_number(header(hdr), base)
+        end
+
+        def value_to_number(value, base = 10)
+          # It's important to make a difference between no header,
+          # and a header defined to zero.
+          return if value.nil?
+
+          # Be sure we have a string
+          value = value.to_s
+
+          # If we are parsing base16 number then truncate to 64-bit
+          value = DistributedTracing::Headers::Helpers.truncate_base16_number(value) if base == 16
+
+          # Convert header to an integer
+          # DEV: Ruby `.to_i` will return `0` if a number could not be parsed
+          num = value.to_i(base)
+
+          # Ensure the parsed number is the same as the original string value
+          # e.g. We want to make sure to throw away `'nan'.to_i == 0`
+          return unless num.to_s(base) == value
+
+          num
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/distributed_tracing/headers/helpers.rb

@@ -0,0 +1,45 @@
+require 'ddtrace/configuration'
+require 'ddtrace/span'
+require 'ddtrace/ext/priority'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # Helpers module provides common helper functions for distributed tracing headers
+      module Helpers
+        # Base provides common methods for distributed header helper classes
+        def self.clamp_sampling_priority(sampling_priority)
+          # B3 doesn't have our -1 (USER_REJECT) and 2 (USER_KEEP) priorities so convert to acceptable 0/1
+          if sampling_priority < 0
+            sampling_priority = Ext::Priority::AUTO_REJECT
+          elsif sampling_priority > 1
+            sampling_priority = Ext::Priority::AUTO_KEEP
+          end
+
+          sampling_priority
+        end
+
+        def self.truncate_base16_number(value)
+          # Lowercase if we want to parse base16 e.g. 3E8 => 3e8
+          # DEV: Ruby will parse `3E8` just fine, but to test
+          #      `num.to_s(base) == value` we need to lowercase
+          value = value.downcase
+
+          # Truncate to trailing 16 characters if length is greater than 16
+          # https://github.com/apache/incubator-zipkin/blob/21fe362899fef5c593370466bc5707d3837070c2/zipkin/src/main/java/zipkin2/storage/StorageComponent.java#L49-L53
+          # DEV: This ensures we truncate B3 128-bit trace and span ids to 64-bit
+          value = value[value.length - 16, 16] if value.length > 16
+
+          # Remove any leading zeros
+          # DEV: When we call `num.to_s(16)` later Ruby will not add leading zeros
+          #      for us so we want to make sure the comparision will work as expected
+          # DEV: regex, remove all leading zeros up until we find the last 0 in the string
+          #      or we find the first non-zero, this allows `'0000' -> '0'` and `'00001' -> '1'`
+          value = value.sub(/^0*(?=(0$)|[^0])/, '')
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/encoding.rb

@@ -0,0 +1,69 @@
+require 'json'
+require 'msgpack'
+
+module Datadog
+  # Encoding module that encodes data for the AgentTransport
+  module Encoding
+    # Encoder interface that provides the logic to encode traces and service
+    module Encoder
+      def content_type
+        raise NotImplementedError
+      end
+
+      # Concatenates a list of elements previously encoded by +#encode+.
+      def join(encoded_elements)
+        raise NotImplementedError
+      end
+
+      # Serializes a single trace into a String suitable for network transmission.
+      def encode(_)
+        raise NotImplementedError
+      end
+    end
+
+    # Encoder for the JSON format
+    module JSONEncoder
+      extend Encoder
+
+      CONTENT_TYPE = 'application/json'.freeze
+
+      module_function
+
+      def content_type
+        CONTENT_TYPE
+      end
+
+      def encode(obj)
+        JSON.dump(obj)
+      end
+
+      def join(encoded_data)
+        "[#{encoded_data.join(',')}]"
+      end
+    end
+
+    # Encoder for the Msgpack format
+    module MsgpackEncoder
+      extend Encoder
+
+      module_function
+
+      CONTENT_TYPE = 'application/msgpack'.freeze
+
+      def content_type
+        CONTENT_TYPE
+      end
+
+      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

@@ -0,0 +1,31 @@
+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.strip.downcase == 'true' : default
+      end
+
+      def env_to_int(var, default = nil)
+        ENV.key?(var) ? ENV[var].to_i : default
+      end
+
+      def env_to_float(var, default = nil)
+        ENV.key?(var) ? ENV[var].to_f : default
+      end
+
+      def env_to_list(var, default = [])
+        if ENV.key?(var)
+          ENV[var].split(',').map(&:strip)
+        else
+          default
+        end
+      end
+    end
+
+    extend Helpers
+  end
+end

data/lib/ddtrace/error.rb

@@ -0,0 +1,27 @@
+# Datadog global namespace
+module Datadog
+  # Error is a value-object responsible for sanitizing/encapsulating error data
+  class Error
+    attr_reader :type, :message, :backtrace
+
+    def self.build_from(value)
+      case value
+      when Error then value
+      when Array then new(*value)
+      when Exception then new(value.class, value.message, value.backtrace)
+      when ContainsMessage then new(value.class, value.message)
+      else BlankError
+      end
+    end
+
+    def initialize(type = nil, message = nil, backtrace = nil)
+      backtrace = Array(backtrace).join("\n")
+      @type = Utils.utf8_encode(type)
+      @message = Utils.utf8_encode(message)
+      @backtrace = Utils.utf8_encode(backtrace)
+    end
+
+    BlankError = Error.new
+    ContainsMessage = ->(v) { v.respond_to?(:message) }
+  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