ls-trace 0.1.1

data/lib/ddtrace/contrib/sinatra/tracer.rb

@@ -0,0 +1,84 @@
+require 'sinatra/base'
+
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/errors'
+require 'ddtrace/ext/http'
+require 'ddtrace/propagation/http_propagator'
+
+require 'ddtrace/contrib/sinatra/ext'
+require 'ddtrace/contrib/sinatra/tracer_middleware'
+require 'ddtrace/contrib/sinatra/env'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # Datadog::Contrib::Sinatra::Tracer is a Sinatra extension which traces
+      # requests.
+      module Tracer
+        def route(verb, action, *)
+          # Keep track of the route name when the app is instantiated for an
+          # incoming request.
+          condition do
+            # If the option to prepend script names is enabled, then
+            # prepend the script name from the request onto the action.
+            @datadog_route = if Datadog.configuration[:sinatra][:resource_script_names]
+                               "#{request.script_name}#{action}"
+                             else
+                               action
+                             end
+          end
+
+          super
+        end
+
+        def self.registered(app)
+          ::Sinatra::Base.module_eval do
+            def render(engine, data, *)
+              output = ''
+              tracer = Datadog.configuration[:sinatra][:tracer]
+              if tracer.enabled
+                tracer.trace(Ext::SPAN_RENDER_TEMPLATE, span_type: Datadog::Ext::HTTP::TEMPLATE) do |span|
+                  # If data is a string, it is a literal template and we don't
+                  # want to record it.
+                  span.set_tag(Ext::TAG_TEMPLATE_NAME, data) if data.is_a? Symbol
+
+                  output = super
+                end
+              else
+                output = super
+              end
+
+              output
+            end
+          end
+
+          app.use TracerMiddleware
+
+          app.before do
+            return unless Datadog.configuration[:sinatra][:tracer].enabled
+
+            span = Sinatra::Env.datadog_span(env)
+            span.set_tag(Datadog::Ext::HTTP::URL, request.path)
+            span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
+          end
+
+          app.after do
+            return unless Datadog.configuration[:sinatra][:tracer].enabled
+
+            span = Sinatra::Env.datadog_span(env)
+
+            unless span
+              Datadog::Tracer.log.error('missing request span in :after hook')
+              return
+            end
+
+            span.resource = "#{request.request_method} #{@datadog_route}"
+            span.set_tag(Ext::TAG_ROUTE_PATH, @datadog_route)
+            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
+            span.set_error(env['sinatra.error']) if response.server_error?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sinatra/tracer_middleware.rb

@@ -0,0 +1,72 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/sinatra/ext'
+require 'ddtrace/contrib/sinatra/env'
+require 'ddtrace/contrib/sinatra/headers'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # Middleware used for automatically tagging configured headers and handle request span
+      class TracerMiddleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          # Set the trace context (e.g. distributed tracing)
+          if configuration[:distributed_tracing] && tracer.provider.context.trace_id.nil?
+            context = HTTPPropagator.extract(env)
+            tracer.provider.context = context if context.trace_id
+          end
+
+          # Begin the trace
+          tracer.trace(
+            Ext::SPAN_REQUEST,
+            service: configuration[:service_name],
+            span_type: Datadog::Ext::HTTP::TYPE_INBOUND
+          ) do |span|
+            Sinatra::Env.set_datadog_span(env, span)
+
+            Sinatra::Env.request_header_tags(env, configuration[:headers][:request]).each do |name, value|
+              span.set_tag(name, value) if span.get_tag(name).nil?
+            end
+
+            # Run application stack
+            status, headers, response_body = @app.call(env)
+
+            Sinatra::Headers.response_header_tags(headers, configuration[:headers][:response]).each do |name, value|
+              span.set_tag(name, value) if span.get_tag(name).nil?
+            end
+
+            # Set analytics sample rate
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+            [status, headers, response_body]
+          end
+        end
+
+        private
+
+        def tracer
+          configuration[:tracer]
+        end
+
+        def analytics_enabled?
+          Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+        end
+
+        def analytics_sample_rate
+          configuration[:analytics_sample_rate]
+        end
+
+        def configuration
+          Datadog.configuration[:sinatra]
+        end
+
+        def header_to_rack_header(name)
+          "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sucker_punch/configuration/settings.rb

@@ -0,0 +1,25 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/sucker_punch/ext'
+
+module Datadog
+  module Contrib
+    module SuckerPunch
+      module Configuration
+        # Custom settings for the SuckerPunch integration
+        class Settings < Contrib::Configuration::Settings
+          option :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.lazy
+          end
+
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sucker_punch/exception_handler.rb

@@ -0,0 +1,26 @@
+require 'sucker_punch'
+
+module Datadog
+  module Contrib
+    module SuckerPunch
+      # Patches `sucker_punch` exception handling
+      module ExceptionHandler
+        METHOD = ->(e, *) { raise(e) }
+
+        module_function
+
+        def patch!
+          ::SuckerPunch.class_eval do
+            class << self
+              alias_method :__exception_handler, :exception_handler
+
+              def exception_handler
+                ::Datadog::Contrib::SuckerPunch::ExceptionHandler::METHOD
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sucker_punch/ext.rb

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module SuckerPunch
+      # SuckerPunch integration constants
+      module Ext
+        APP = 'sucker_punch'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_SUCKER_PUNCH_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_SUCKER_PUNCH_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'sucker_punch'.freeze
+        SPAN_PERFORM = 'sucker_punch.perform'.freeze
+        SPAN_PERFORM_ASYNC = 'sucker_punch.perform_async'.freeze
+        SPAN_PERFORM_IN = 'sucker_punch.perform_in'.freeze
+        TAG_PERFORM_IN = 'sucker_punch.perform_in'.freeze
+        TAG_QUEUE = 'sucker_punch.queue'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sucker_punch/instrumentation.rb

@@ -0,0 +1,70 @@
+require 'sucker_punch'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/sucker_punch/ext'
+
+module Datadog
+  module Contrib
+    module SuckerPunch
+      # Defines instrumentation patches for the `sucker_punch` gem
+      module Instrumentation
+        module_function
+
+        # rubocop:disable Metrics/MethodLength
+        def patch!
+          ::SuckerPunch::Job::ClassMethods.class_eval do
+            alias_method :__run_perform_without_datadog, :__run_perform
+            def __run_perform(*args)
+              pin = Datadog::Pin.get_from(::SuckerPunch)
+              pin.tracer.provider.context = Datadog::Context.new
+
+              __with_instrumentation(Ext::SPAN_PERFORM) do |span|
+                span.resource = "PROCESS #{self}"
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+                end
+                __run_perform_without_datadog(*args)
+              end
+            rescue => e
+              ::SuckerPunch.__exception_handler.call(e, self, args)
+            end
+
+            alias_method :__perform_async, :perform_async
+            def perform_async(*args)
+              __with_instrumentation(Ext::SPAN_PERFORM_ASYNC) do |span|
+                span.resource = "ENQUEUE #{self}"
+                __perform_async(*args)
+              end
+            end
+
+            alias_method :__perform_in, :perform_in
+            def perform_in(interval, *args)
+              __with_instrumentation(Ext::SPAN_PERFORM_IN) do |span|
+                span.resource = "ENQUEUE #{self}"
+                span.set_tag(Ext::TAG_PERFORM_IN, interval)
+                __perform_in(interval, *args)
+              end
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration[:sucker_punch]
+            end
+
+            def __with_instrumentation(name)
+              pin = Datadog::Pin.get_from(::SuckerPunch)
+
+              pin.tracer.trace(name) do |span|
+                span.service = pin.service
+                span.span_type = pin.app_type
+                span.set_tag(Ext::TAG_QUEUE, to_s)
+                yield span
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sucker_punch/integration.rb

@@ -0,0 +1,36 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/sucker_punch/configuration/settings'
+require 'ddtrace/contrib/sucker_punch/patcher'
+
+module Datadog
+  module Contrib
+    module SuckerPunch
+      # Description of SuckerPunch integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :sucker_punch, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['sucker_punch'] && Gem.loaded_specs['sucker_punch'].version
+        end
+
+        def self.present?
+          super && defined?(::SuckerPunch)
+        end
+
+        def self.compatible?
+          super && Gem::Version.new(::SuckerPunch::VERSION) >= Gem::Version.new('2.0.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sucker_punch/patcher.rb

@@ -0,0 +1,48 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/sucker_punch/ext'
+
+module Datadog
+  module Contrib
+    module SuckerPunch
+      # Patcher enables patching of 'sucker_punch' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:sucker_punch)
+        end
+
+        def patch
+          do_once(:sucker_punch) do
+            begin
+              require 'ddtrace/contrib/sucker_punch/exception_handler'
+              require 'ddtrace/contrib/sucker_punch/instrumentation'
+
+              add_pin!
+              ExceptionHandler.patch!
+              Instrumentation.patch!
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply SuckerPunch integration: #{e}")
+            end
+          end
+        end
+
+        def add_pin!
+          Pin.new(
+            get_option(:service_name),
+            app: Ext::APP,
+            app_type: Datadog::Ext::AppTypes::WORKER,
+            tracer: get_option(:tracer)
+          ).onto(::SuckerPunch)
+        end
+
+        def get_option(option)
+          Datadog.configuration[:sucker_punch].get_option(option)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/correlation.rb

@@ -0,0 +1,28 @@
+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
+      def initialize(*args)
+        super
+        self.trace_id = trace_id || 0
+        self.span_id = span_id || 0
+      end
+
+      def to_s
+        "dd.trace_id=#{trace_id} dd.span_id=#{span_id}"
+      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?
+      Identifier.new(context.trace_id, context.span_id).freeze
+    end
+  end
+end

data/lib/ddtrace/diagnostics/health.rb

@@ -0,0 +1,30 @@
+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 :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 :writer_cpu_time, Ext::Diagnostics::Health::Metrics::METRIC_WRITER_CPU_TIME
+      end
+
+      module_function
+
+      def metrics
+        Datadog.configuration.diagnostics.health_metrics
+      end
+    end
+  end
+end