ls-trace 0.1.1

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,65 @@
+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
+
+      # 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)
+      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.
+      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
+    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
+    end
+  end
+end

data/lib/ddtrace/environment.rb

@@ -0,0 +1,23 @@
+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
+      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
+  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/ext/analytics.rb

@@ -0,0 +1,11 @@
+module Datadog
+  module Ext
+    # Defines constants for trace analytics
+    module Analytics
+      DEFAULT_SAMPLE_RATE = 1.0
+      ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'.freeze
+      TAG_ENABLED = 'analytics.enabled'.freeze
+      TAG_SAMPLE_RATE = '_dd1.sr.eausr'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/app_types.rb

@@ -0,0 +1,11 @@
+module Datadog
+  module Ext
+    module AppTypes
+      WEB = 'web'.freeze
+      DB = 'db'.freeze
+      CACHE = 'cache'.freeze
+      WORKER = 'worker'.freeze
+      CUSTOM = 'custom'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/diagnostics.rb

@@ -0,0 +1,25 @@
+module Datadog
+  module Ext
+    module Diagnostics
+      # Health
+      module Health
+        # Metrics
+        module Metrics
+          ENV_ENABLED = 'DD_HEALTH_METRICS_ENABLED'.freeze
+
+          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_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_TRACES_FILTERED = 'datadog.tracer.traces.filtered'.freeze
+          METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/distributed.rb

@@ -0,0 +1,33 @@
+module Datadog
+  module Ext
+    module DistributedTracing
+      # HTTP headers one should set for distributed tracing.
+      # These are cross-language (eg: Python, Go and other implementations should honor these)
+      HTTP_HEADER_TRACE_ID = 'x-datadog-trace-id'.freeze
+      HTTP_HEADER_PARENT_ID = 'x-datadog-parent-id'.freeze
+      HTTP_HEADER_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'.freeze
+      SAMPLING_PRIORITY_KEY = '_sampling_priority_v1'.freeze
+      HTTP_HEADER_ORIGIN = 'x-datadog-origin'.freeze
+      ORIGIN_KEY = '_dd.origin'.freeze
+
+      # B3 headers used for distributed tracing
+      B3_HEADER_TRACE_ID = 'x-b3-traceid'.freeze
+      B3_HEADER_SPAN_ID = 'x-b3-spanid'.freeze
+      B3_HEADER_SAMPLED = 'x-b3-sampled'.freeze
+      B3_HEADER_SINGLE = 'b3'.freeze
+
+      # Distributed tracing propagation options
+      PROPAGATION_STYLE_DATADOG = 'Datadog'.freeze
+      PROPAGATION_STYLE_B3 = 'B3'.freeze
+      PROPAGATION_STYLE_B3_SINGLE_HEADER = 'B3 single header'.freeze
+      PROPAGATION_INJECT_STYLE_ENV = 'DD_PROPAGATION_INJECT_STYLE'.freeze
+      PROPAGATION_EXTRACT_STYLE_ENV = 'DD_PROPAGATION_EXTRACT_STYLE'.freeze
+
+      # gRPC metadata keys for distributed tracing. https://github.com/grpc/grpc-go/blob/v1.10.x/Documentation/grpc-metadata.md
+      GRPC_METADATA_TRACE_ID = 'x-datadog-trace-id'.freeze
+      GRPC_METADATA_PARENT_ID = 'x-datadog-parent-id'.freeze
+      GRPC_METADATA_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'.freeze
+      GRPC_METADATA_ORIGIN = 'x-datadog-origin'.freeze
+    end
+  end
+end