ls-trace 0.1.1

data/lib/ddtrace/ext/errors.rb

@@ -0,0 +1,10 @@
+module Datadog
+  module Ext
+    module Errors
+      STATUS = 1
+      MSG = 'error.msg'.freeze
+      TYPE = 'error.type'.freeze
+      STACK = 'error.stack'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/forced_tracing.rb

@@ -0,0 +1,25 @@
+require 'ddtrace/ext/manual_tracing'
+require 'ddtrace/tracer'
+
+module Datadog
+  module Ext
+    # Defines constants for forced tracing
+    module ForcedTracing
+      @deprecation_warning_shown = false
+
+      def self.const_missing(name)
+        super unless Ext::ManualTracing.const_defined?(name)
+
+        # Only log each deprecation warning once (safeguard against log spam)
+        unless @deprecation_warning_shown
+          Datadog::Tracer.log.warn(
+            'forced tracing: Datadog::Ext::ForcedTracing has been renamed to Datadog::Ext::ManualTracing'
+          )
+          @deprecation_warning_shown = true
+        end
+
+        Ext::ManualTracing.const_get(name)
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/http.rb

@@ -0,0 +1,46 @@
+module Datadog
+  module Ext
+    module HTTP
+      BASE_URL = 'http.base_url'.freeze
+      ERROR_RANGE = 500...600
+      METHOD = 'http.method'.freeze
+      STATUS_CODE = 'http.status_code'.freeze
+      TEMPLATE = 'template'.freeze
+      TYPE_INBOUND = 'web'.freeze
+      TYPE_OUTBOUND = 'http'.freeze
+      TYPE_PROXY = 'proxy'.freeze
+      URL = 'http.url'.freeze
+
+      # General header functionality
+      module Headers
+        module_function
+
+        def to_tag(name)
+          name.to_s.downcase.gsub(/[-\s]/, '_')
+        end
+      end
+
+      # Request headers
+      module RequestHeaders
+        PREFIX = 'http.request.headers'.freeze
+
+        module_function
+
+        def to_tag(name)
+          "#{PREFIX}.#{Headers.to_tag(name)}"
+        end
+      end
+
+      # Response headers
+      module ResponseHeaders
+        PREFIX = 'http.response.headers'.freeze
+
+        module_function
+
+        def to_tag(name)
+          "#{PREFIX}.#{Headers.to_tag(name)}"
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/manual_tracing.rb

@@ -0,0 +1,9 @@
+module Datadog
+  module Ext
+    # Defines constants for manual tracing
+    module ManualTracing
+      TAG_KEEP = 'manual.keep'.freeze
+      TAG_DROP = 'manual.drop'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/metrics.rb

@@ -0,0 +1,15 @@
+module Datadog
+  module Ext
+    module Metrics
+      DEFAULT_HOST = '127.0.0.1'.freeze
+      DEFAULT_PORT = 8125
+      ENV_DEFAULT_HOST = 'DD_AGENT_HOST'.freeze
+      ENV_DEFAULT_PORT = 'DD_METRIC_AGENT_PORT'.freeze
+
+      TAG_LANG = 'language'.freeze
+      TAG_LANG_INTERPRETER = 'language-interpreter'.freeze
+      TAG_LANG_VERSION = 'language-version'.freeze
+      TAG_TRACER_VERSION = 'tracer-version'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/net.rb

@@ -0,0 +1,10 @@
+module Datadog
+  module Ext
+    module NET
+      ENV_REPORT_HOSTNAME = 'DD_TRACE_REPORT_HOSTNAME'.freeze
+      TAG_HOSTNAME = '_dd.hostname'.freeze
+      TARGET_HOST = 'out.host'.freeze
+      TARGET_PORT = 'out.port'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/priority.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Ext
+    # Priority is a hint given to the backend so that it knows which traces to reject or kept.
+    # In a distributed context, it should be set before any context propagation (fork, RPC calls) to be effective.
+    module Priority
+      # Use this to explicitely inform the backend that a trace should be rejected and not stored.
+      USER_REJECT = -1
+      # Used by the builtin sampler to inform the backend that a trace should be rejected and not stored.
+      AUTO_REJECT = 0
+      # Used by the builtin sampler to inform the backend that a trace should be kept and stored.
+      AUTO_KEEP = 1
+      # Use this to explicitely inform the backend that a trace should be kept and stored.
+      USER_KEEP = 2
+    end
+  end
+end

data/lib/ddtrace/ext/runtime.rb

@@ -0,0 +1,26 @@
+require 'ddtrace/version'
+
+module Datadog
+  module Ext
+    module Runtime
+      # Identity
+      LANG = 'ruby'.freeze
+      LANG_INTERPRETER = (RUBY_ENGINE + '-' + RUBY_PLATFORM).freeze
+      LANG_VERSION = RUBY_VERSION
+      TRACER_VERSION = Datadog::VERSION::STRING
+
+      TAG_LANG = 'language'.freeze
+
+      # Metrics
+      module Metrics
+        ENV_ENABLED = 'DD_RUNTIME_METRICS_ENABLED'.freeze
+
+        METRIC_CLASS_COUNT = 'runtime.ruby.class_count'.freeze
+        METRIC_GC_PREFIX = 'runtime.ruby.gc'.freeze
+        METRIC_THREAD_COUNT = 'runtime.ruby.thread_count'.freeze
+
+        TAG_SERVICE = 'service'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/sql.rb

@@ -0,0 +1,8 @@
+module Datadog
+  module Ext
+    module SQL
+      TYPE = 'sql'.freeze
+      QUERY = 'sql.query'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/transport.rb

@@ -0,0 +1,17 @@
+module Datadog
+  module Ext
+    module Transport
+      module HTTP
+        DEFAULT_HOST = '127.0.0.1'.freeze
+        DEFAULT_PORT = 8126
+        ENV_DEFAULT_HOST = 'DD_AGENT_HOST'.freeze
+        ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'.freeze
+        HEADER_CONTAINER_ID = 'Datadog-Container-ID'.freeze
+        HEADER_META_LANG = 'Datadog-Meta-Lang'.freeze
+        HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'.freeze
+        HEADER_META_LANG_INTERPRETER = 'Datadog-Meta-Lang-Interpreter'.freeze
+        HEADER_META_TRACER_VERSION = 'Datadog-Meta-Tracer-Version'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/forced_tracing.rb

@@ -0,0 +1,36 @@
+require 'ddtrace/ext/manual_tracing'
+require 'ddtrace/ext/priority'
+
+module Datadog
+  # Defines analytics behavior
+  module ForcedTracing
+    class << self
+      def keep(span)
+        return if span.nil? || span.context.nil?
+        span.context.sampling_priority = Datadog::Ext::Priority::USER_KEEP
+      end
+
+      def drop(span)
+        return if span.nil? || span.context.nil?
+        span.context.sampling_priority = Datadog::Ext::Priority::USER_REJECT
+      end
+    end
+
+    # Extension for Datadog::Span
+    module Span
+      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 Ext::ManualTracing::TAG_KEEP
+          ForcedTracing.keep(self) unless value == false
+        when Ext::ManualTracing::TAG_DROP
+          ForcedTracing.drop(self) unless value == false
+        else
+          # Otherwise, set the tag normally.
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/logger.rb

@@ -0,0 +1,39 @@
+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
+    def initialize(*args, &block)
+      super
+      self.progname = LOG_PREFIX
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      where = ''
+
+      # We are in debug mode, or this is an error, add stack trace to help debugging
+      if debug? || severity >= ::Logger::ERROR
+        c = caller
+        where = "(#{c[1]}) " if c.length > 1
+      end
+
+      if message.nil?
+        if block_given?
+          super(severity, message, progname) do
+            "[#{self.progname}] #{where}#{yield}"
+          end
+        else
+          super(severity, message, "[#{self.progname}] #{where}#{progname}")
+        end
+      else
+        super(severity, "[#{self.progname}] #{where}#{message}")
+      end
+    end
+
+    alias log add
+  end
+end

data/lib/ddtrace/metrics.rb

@@ -0,0 +1,215 @@
+require 'ddtrace/ext/metrics'
+
+require 'set'
+require 'logger'
+require 'ddtrace/utils/time'
+require 'ddtrace/runtime/identity'
+
+module Datadog
+  # Acts as client for sending metrics (via Statsd)
+  # Wraps a Statsd client with default tags and additional configuration.
+  class Metrics
+    attr_reader :statsd
+
+    def initialize(options = {})
+      @statsd = options.fetch(:statsd) { default_statsd_client if supported? }
+      @enabled = options.fetch(:enabled, true)
+    end
+
+    def supported?
+      version = Gem.loaded_specs['dogstatsd-ruby'] \
+                  && Gem.loaded_specs['dogstatsd-ruby'].version
+
+      !version.nil? && (version >= Gem::Version.new('3.3.0'))
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def enabled=(enabled)
+      @enabled = (enabled == true)
+    end
+
+    def default_hostname
+      ENV.fetch(Datadog::Ext::Metrics::ENV_DEFAULT_HOST, Datadog::Ext::Metrics::DEFAULT_HOST)
+    end
+
+    def default_port
+      ENV.fetch(Datadog::Ext::Metrics::ENV_DEFAULT_PORT, Datadog::Ext::Metrics::DEFAULT_PORT).to_i
+    end
+
+    def default_statsd_client
+      require 'datadog/statsd' unless defined?(::Datadog::Statsd)
+
+      # Create a StatsD client that points to the agent.
+      Datadog::Statsd.new(default_hostname, default_port)
+    end
+
+    def configure(options = {})
+      @statsd = options[:statsd] if options.key?(:statsd)
+      self.enabled = options[:enabled] if options.key?(:enabled)
+    end
+
+    def send_stats?
+      enabled? && !statsd.nil?
+    end
+
+    def count(stat, value = nil, options = nil, &block)
+      return unless send_stats? && statsd.respond_to?(:count)
+      value, options = yield if block_given?
+      raise ArgumentError if value.nil?
+
+      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}")
+    end
+
+    def distribution(stat, value = nil, options = nil, &block)
+      return unless send_stats? && statsd.respond_to?(:distribution)
+      value, options = yield if block_given?
+      raise ArgumentError if value.nil?
+
+      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}")
+    end
+
+    def increment(stat, options = nil)
+      return unless send_stats? && statsd.respond_to?(:increment)
+      options = yield if block_given?
+
+      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}")
+    end
+
+    def gauge(stat, value = nil, options = nil, &block)
+      return unless send_stats? && statsd.respond_to?(:gauge)
+      value, options = yield if block_given?
+      raise ArgumentError if value.nil?
+
+      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}")
+    end
+
+    def time(stat, options = nil)
+      return yield unless send_stats?
+
+      # Calculate time, send it as a distribution.
+      start = Utils::Time.get_time
+      return yield
+    ensure
+      begin
+        if send_stats? && !start.nil?
+          finished = Utils::Time.get_time
+          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}")
+      end
+    end
+
+    def send_metrics(metrics)
+      metrics.each { |m| send(m.type, *[m.name, m.value, m.options].compact) }
+    end
+
+    Metric = Struct.new(:type, :name, :value, :options) do
+      def initialize(*args)
+        super
+        self.options = options || {}
+      end
+    end
+
+    # For defining and adding default options to metrics
+    module Options
+      DEFAULT = {
+        tags: DEFAULT_TAGS = [
+          "#{Ext::Metrics::TAG_LANG}:#{Runtime::Identity.lang}".freeze,
+          "#{Ext::Metrics::TAG_LANG_INTERPRETER}:#{Runtime::Identity.lang_interpreter}".freeze,
+          "#{Ext::Metrics::TAG_LANG_VERSION}:#{Runtime::Identity.lang_version}".freeze,
+          "#{Ext::Metrics::TAG_TRACER_VERSION}:#{Runtime::Identity.tracer_version}".freeze
+        ].freeze
+      }.freeze
+
+      def metric_options(options = nil)
+        return default_metric_options if options.nil?
+
+        default_metric_options.merge(options) do |key, old_value, new_value|
+          case key
+          when :tags
+            old_value.dup.concat(new_value).uniq
+          else
+            new_value
+          end
+        end
+      end
+
+      def default_metric_options
+        # Return dupes, so that the constant isn't modified,
+        # and defaults are unfrozen for mutation in Statsd.
+        DEFAULT.dup.tap do |options|
+          options[:tags] = options[:tags].dup
+        end
+      end
+    end
+
+    # For defining and adding helpers to metrics
+    module Helpers
+      [
+        :count,
+        :distribution,
+        :increment,
+        :gauge,
+        :time
+      ].each do |metric_type|
+        define_method(metric_type) do |name, stat|
+          name = name.to_sym
+          define_method(name) do |*args, &block|
+            send(metric_type, stat, *args, &block)
+          end
+        end
+      end
+    end
+
+    module Logging
+      # Surrogate for Datadog::Statsd to log elsewhere
+      class Adapter
+        attr_accessor :logger
+
+        def initialize(logger = nil)
+          @logger = logger || Logger.new(STDOUT).tap do |l|
+            l.level = Logger::INFO
+            l.progname = nil
+            l.formatter = proc do |_severity, datetime, _progname, msg|
+              stat = JSON.parse(msg[3..-1]) # Trim off leading progname...
+              "#{JSON.dump(timestamp: datetime.to_i, message: 'Metric sent.', metric: stat)}\n"
+            end
+          end
+        end
+
+        def count(stat, value, options = nil)
+          logger.info({ stat: stat, type: :count, value: value, options: options }.to_json)
+        end
+
+        def distribution(stat, value, options = nil)
+          logger.info({ stat: stat, type: :distribution, value: value, options: options }.to_json)
+        end
+
+        def increment(stat, options = nil)
+          logger.info({ stat: stat, type: :increment, options: options }.to_json)
+        end
+
+        def gauge(stat, value, options = nil)
+          logger.info({ stat: stat, type: :gauge, value: value, options: options }.to_json)
+        end
+      end
+    end
+
+    # Make available on for both class and instance.
+    include Options
+    extend Options
+    extend Helpers
+  end
+end