epsagon 0.0.9 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbcd3ad1c94c24be608924993e0c0c6fc0455982b51f66a61e159fce8713e607
-  data.tar.gz: 005d41bf64026ec6918eeaa9d99a77ee8e108b8d1574391494604eb99dd76733
+  metadata.gz: 71cba45cc332a05fb153ec269dd3370a5a6e925f53db822e283247b4dca3d298
+  data.tar.gz: 1a083edb95e3648a3bb3ac8943c1bb1e3cae0ac60aca1795bf9e496851d83dfa
 SHA512:
-  metadata.gz: ad16af491cc509358edfc44dda23c838604a33beb6d6ad25d84b183bc0e0d4f4e12f9991a92fa91d54b10f2fb0dc2ebb33f4bf75244b54a0848bc3a584915d41
-  data.tar.gz: 143981531b488487e9bd13bcf58d412a02a1efcd53cdff9548a4157c49041eb5305796016d941fb5e0e3446e914106aca56b94303803b99fd96d85d01d586a27
+  metadata.gz: 84c185df8c80ba4bf24905e7e84dabe300bdf40d3b17a761cd024cdabf89a1ccabf3b2e2c9e20bfd8495973700cf0b46b4c19e133f8dcc8310cebde1b550adc6
+  data.tar.gz: 64d07d50a14609618ed1f836e05b1d05a89de2b5c360608e8622ed64a10df5062fd29cc24ea3beb6fecb1f95401727e89599d689afbb4189e6985a2248719330

data/lib/epsagon.rb

@@ -9,19 +9,23 @@ require 'opentelemetry/exporter/otlp'
 require_relative 'instrumentation/sinatra'
 require_relative 'instrumentation/net_http'
 require_relative 'instrumentation/faraday'
+require_relative 'instrumentation/aws_sdk'
+require_relative 'instrumentation/rails'
 require_relative 'util'
 
 Bundler.require
 
 # Epsagon tracing main entry point
 module Epsagon
+  DEFAULT_BACKEND = 'opentelemetry.tc.epsagon.com:443/traces'
+
   @@epsagon_config = {
-      metadata_only: ENV['EPSAGON_METADATA']&.to_s&.downcase != 'false',
-      debug: ENV['EPSAGON_DEBUG']&.to_s&.downcase == 'true',
-      token: ENV['EPSAGON_TOKEN'],
-      app_name: ENV['EPSAGON_APP_NAME'],
-      backend: ENV['EPSAGON_BACKEND'] || 'localhost:55681/v1/trace'
-    }
+    metadata_only: ENV['EPSAGON_METADATA']&.to_s&.downcase != 'false',
+    debug: ENV['EPSAGON_DEBUG']&.to_s&.downcase == 'true',
+    token: ENV['EPSAGON_TOKEN'],
+    app_name: ENV['EPSAGON_APP_NAME'],
+    backend: ENV['EPSAGON_BACKEND'] || DEFAULT_BACKEND
+  }
 
   module_function
 
@@ -39,14 +43,16 @@ module Epsagon
     configurator.use 'EpsagonSinatraInstrumentation', { epsagon: @@epsagon_config }
     configurator.use 'EpsagonNetHTTPInstrumentation', { epsagon: @@epsagon_config }
     configurator.use 'EpsagonFaradayInstrumentation', { epsagon: @@epsagon_config }
+    configurator.use 'EpsagonAwsSdkInstrumentation', { epsagon: @@epsagon_config }
+    configurator.use 'EpsagonRailsInstrumentation', { epsagon: @@epsagon_config }
 
     if @@epsagon_config[:debug]
       configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
         OpenTelemetry::Exporter::OTLP::Exporter.new(headers: {
-                            'x-epsagon-token' => @@epsagon_config[:token]
-                          },
-                          endpoint: @@epsagon_config[:backend],
-                          insecure: @@epsagon_config[:insecure] || false)
+                                                      'x-epsagon-token' => @@epsagon_config[:token]
+                                                    },
+                                                    endpoint: @@epsagon_config[:backend],
+                                                    insecure: @@epsagon_config[:insecure] || false)
       )
 
       configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
@@ -62,7 +68,6 @@ module Epsagon
       )
     end
   end
-
 end
 
 # monkey patch to include epsagon confs

data/lib/instrumentation/aws_sdk.rb

@@ -2,32 +2,6 @@
 
 require_relative '../util'
 
-# AWS SDK plugin for epsagon instrumentation
-class EpsagonAwsPlugin < Seahorse::Client::Plugin
-  def add_handlers(handlers, _)
-    handlers.add(EpsagonAwsHandler, step: :validate)
-  end
-end
-
-# Generates Spans for all uses of AWS SDK
-class EpsagonAwsHandler < Seahorse::Client::Handler
-  def call(context)
-    tracer.in_span('') do |span|
-      @handler.call(context).tap do
-        span.set_attribute('aws.operation', context[:command])
-        span.set_attribute('aws.status_code', context[:status_code])
-        span.set_attribute('aws.service', context[:service_name])
-        span.set_attribute('aws.account_id', context[:account_id])
-        span.set_attribute('aws.status_code', context[:status_code])
-      end
-    end
-  end
-
-  def tracer
-    EpsagonAwsSdkInstrumentation.instance.tracer
-  end
-end
-
 # AWS SDK epsagon instrumentation
 class EpsagonAwsSdkInstrumentation < OpenTelemetry::Instrumentation::Base
   VERSION = '0.0.0'
@@ -143,6 +117,7 @@ class EpsagonAwsSdkInstrumentation < OpenTelemetry::Instrumentation::Base
   ].freeze
 
   install do |_|
+    require_relative 'aws_sdk_plugin'
     ::Seahorse::Client::Base.add_plugin(EpsagonAwsPlugin)
     loaded_constants.each { |klass| klass.add_plugin(EpsagonAwsPlugin) }
   end

data/lib/instrumentation/aws_sdk_plugin.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-core'
+require 'opentelemetry/common'
+require 'opentelemetry/sdk'
+
+def untraced(&block)
+  OpenTelemetry::Trace.with_span(OpenTelemetry::Trace::Span.new, &block)
+end
+
+# AWS SDK plugin for epsagon instrumentation
+class EpsagonAwsPlugin < Seahorse::Client::Plugin
+  def add_handlers(handlers, _)
+    handlers.add(EpsagonAwsHandler, step: :validate)
+  end
+end
+
+# Generates Spans for all uses of AWS SDK
+class EpsagonAwsHandler < Seahorse::Client::Handler
+  def call(context)
+    tracer.in_span('', kind: :client) do |span|
+      untraced do
+        @handler.call(context).tap do
+          span.set_attribute('aws.service', context.client.class.to_s.split('::')[1].downcase)
+          span.set_attribute('aws.operation', context.operation.name)
+          span.set_attribute('aws.region', context.client.config.region)
+          span.set_attribute('http.status_code', context.http_response.status_code)
+        end
+      end
+    end
+  end
+
+  def tracer
+    EpsagonAwsSdkInstrumentation.instance.tracer
+  end
+end

data/lib/instrumentation/epsagon_faraday_middleware.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require_relative '../util'
 require 'faraday'

data/lib/instrumentation/epsagon_rails_middleware.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/trace/status'
+
+module QueueTime
+  REQUEST_START = 'HTTP_X_REQUEST_START'
+  QUEUE_START = 'HTTP_X_QUEUE_START'
+  MINIMUM_ACCEPTABLE_TIME_VALUE = 1_000_000_000
+
+  module_function
+
+  def get_request_start(env, now = nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    header = env[REQUEST_START] || env[QUEUE_START]
+    return unless header
+
+    # nginx header is seconds in the format "t=1512379167.574"
+    # apache header is microseconds in the format "t=1570633834463123"
+    # heroku header is milliseconds in the format "1570634024294"
+    time_string = header.to_s.delete('^0-9')
+    return if time_string.nil?
+
+    # Return nil if the time is clearly invalid
+    time_value = "#{time_string[0, 10]}.#{time_string[10, 6]}".to_f
+    return if time_value.zero? || time_value < MINIMUM_ACCEPTABLE_TIME_VALUE
+
+    # return the request_start only if it's lesser than
+    # current time, to avoid significant clock skew
+    request_start = Time.at(time_value)
+    now ||= Time.now.utc
+    request_start.utc > now ? nil : request_start
+  rescue StandardError => e
+    # in case of an Exception we don't create a
+    # `request.queuing` span
+    OpenTelemetry.logger.debug("[rack] unable to parse request queue headers: #{e}")
+    nil
+  end
+end
+
+class EpsagonRackMiddleware
+  class << self
+    def allowed_rack_request_headers
+      @allowed_rack_request_headers ||= Array(config[:allowed_request_headers]).each_with_object({}) do |header, memo|
+        memo["HTTP_#{header.to_s.upcase.gsub(/[-\s]/, '_')}"] = build_attribute_name('http.request.headers.', header)
+      end
+    end
+
+    def allowed_response_headers
+      @allowed_response_headers ||= Array(config[:allowed_response_headers]).each_with_object({}) do |header, memo|
+        memo[header] = build_attribute_name('http.response.headers.', header)
+        memo[header.to_s.upcase] = build_attribute_name('http.response.headers.', header)
+      end
+    end
+
+    def build_attribute_name(prefix, suffix)
+      prefix + suffix.to_s.downcase.gsub(/[-\s]/, '_')
+    end
+
+    def config
+      EpsagonRailsInstrumentation.instance.config
+    end
+
+    private
+
+    def clear_cached_config
+      @allowed_rack_request_headers = nil
+      @allowed_response_headers = nil
+    end
+  end
+
+  EMPTY_HASH = {}.freeze
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    original_env = env.dup
+    extracted_context = OpenTelemetry.propagation.http.extract(env)
+    frontend_context = create_frontend_span(env, extracted_context)
+
+    # restore extracted context in this process:
+    OpenTelemetry::Context.with_current(frontend_context || extracted_context) do
+      request_span_name = create_request_span_name(env['REQUEST_URI'] || original_env['PATH_INFO'])
+      tracer.in_span(env['HTTP_HOST'] || 'unknown',
+                     attributes: request_span_attributes(env: env),
+                     kind: :server) do |http_span|
+        RackExtension.with_span(http_span) do
+          tracer.in_span(
+              env['HTTP_HOST'],
+              kind: :server,
+              attributes: {type: 'rails'}
+            ) do |framework_span|
+            @app.call(env).tap do |status, headers, response|
+              set_attributes_after_request(http_span, framework_span, status, headers, response)
+            end
+          end
+        end
+      end
+    end
+  ensure
+    finish_span(frontend_context)
+  end
+
+  private
+
+  # return Context with the frontend span as the current span
+  def create_frontend_span(env, extracted_context)
+    request_start_time = QueueTime.get_request_start(env)
+
+    return unless config[:record_frontend_span] && !request_start_time.nil?
+
+    span = tracer.start_span('http_server.proxy',
+                             with_parent: extracted_context,
+                             attributes: {
+                               'start_time' => request_start_time.to_f
+                             },
+                             kind: :server)
+
+    OpenTelemetry::Trace.context_with_span(span, parent_context: extracted_context)
+  end
+
+  def finish_span(context)
+    OpenTelemetry::Trace.current_span(context).finish if context
+  end
+
+  def tracer
+    EpsagonRailsInstrumentation.instance.tracer
+  end
+
+  def request_span_attributes(env:)
+    request = Rack::Request.new(env)
+    path, path_params = request.path.split(';')
+    request_headers = JSON.generate(Hash[*env.select { |k, _v| k.start_with? 'HTTP_' }
+      .collect { |k, v| [k.sub(/^HTTP_/, ''), v] }
+      .collect { |k, v| [k.split('_').collect(&:capitalize).join('-'), v] }
+      .sort
+      .flatten])
+
+    attributes = {
+      'operation' => env['REQUEST_METHOD'],
+      'type' => 'http',
+      'http.scheme' => env['rack.url_scheme'],
+      'http.request.path' => path,
+      'http.request.headers' => request_headers
+    }
+
+    unless config[:epsagon][:metadata_only]
+      request.body.rewind
+      request_body = request.body.read
+      request.body.rewind
+
+      attributes.merge!(Util.epsagon_query_attributes(request.query_string))
+
+      attributes.merge!({
+                          'http.request.body' => request_body,
+                          'http.request.path_params' => path_params,
+                          'http.request.headers.User-Agent' => env['HTTP_USER_AGENT']
+                        })
+    end
+
+    attributes
+  end
+
+  # e.g., "/webshop/articles/4?s=1":
+  def fullpath(env)
+    query_string = env['QUERY_STRING']
+    path = env['SCRIPT_NAME'] + env['PATH_INFO']
+
+    query_string.empty? ? path : "#{path}?#{query_string}"
+  end
+
+  # https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/data-http.md#name
+  #
+  # recommendation: span.name(s) should be low-cardinality (e.g.,
+  # strip off query param value, keep param name)
+  #
+  # see http://github.com/open-telemetry/opentelemetry-specification/pull/416/files
+  def create_request_span_name(request_uri_or_path_info)
+    # NOTE: dd-trace-rb has implemented 'quantization' (which lowers url cardinality)
+    #       see Datadog::Quantization::HTTP.url
+
+    if (implementation = config[:url_quantization])
+      implementation.call(request_uri_or_path_info)
+    else
+      request_uri_or_path_info
+    end
+  end
+
+  def set_attributes_after_request(http_span, _framework_span, status, headers, response)
+    unless config[:epsagon][:metadata_only]
+      http_span.set_attribute('http.response.headers', JSON.generate(headers))
+      http_span.set_attribute('http.response.body', response.join)
+    end
+
+    http_span.set_attribute('http.status_code', status)
+    http_span.status = OpenTelemetry::Trace::Status.http_to_status(status)
+  end
+
+  def allowed_request_headers(env)
+    return EMPTY_HASH if self.class.allowed_rack_request_headers.empty?
+
+    {}.tap do |result|
+      self.class.allowed_rack_request_headers.each do |key, value|
+        result[value] = env[key] if env.key?(key)
+      end
+    end
+  end
+
+  def allowed_response_headers(headers)
+    return EMPTY_HASH if headers.nil?
+    return EMPTY_HASH if self.class.allowed_response_headers.empty?
+
+    {}.tap do |result|
+      self.class.allowed_response_headers.each do |key, value|
+        if headers.key?(key)
+          result[value] = headers[key]
+        else
+          # do case-insensitive match:
+          headers.each do |k, v|
+            if k.upcase == key
+              result[value] = v
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def config
+    EpsagonRailsInstrumentation.instance.config
+  end
+end
+
+# class EpsagonRackInstrumentation < OpenTelemetry::Instrumentation::Base
+#   install do |config|
+#     require_dependencies
+
+#     retain_middleware_names if config[:retain_middleware_names]
+#   end
+
+#   present do
+#     defined?(::Rack)
+#   end
+
+#   private
+
+#   def require_dependencies
+#     require_relative 'middlewares/tracer_middleware'
+#   end
+
+#   MissingApplicationError = Class.new(StandardError)
+
+#   # intercept all middleware-compatible calls, retain class name
+#   def retain_middleware_names
+#     next_middleware = config[:application]
+#     raise MissingApplicationError unless next_middleware
+
+#     while next_middleware
+#       if next_middleware.respond_to?(:call)
+#         next_middleware.singleton_class.class_eval do
+#           alias_method :__call, :call
+
+#           def call(env)
+#             env['RESPONSE_MIDDLEWARE'] = self.class.to_s
+#             __call(env)
+#           end
+#         end
+#       end
+
+#       next_middleware = next_middleware.instance_variable_defined?('@app') &&
+#                         next_middleware.instance_variable_get('@app')
+#     end
+#   end
+# end
+
+class EpsagonRailtie < ::Rails::Railtie
+  config.before_initialize do |app|
+    # EpsagonRackInstrumentation.instance.install({})
+
+    app.middleware.insert_after(
+      ActionDispatch::RequestId,
+      EpsagonRackMiddleware
+    )
+  end
+end

data/lib/instrumentation/faraday.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Patch faraday to include middleware
 module EpsagonFaradayPatch
   def adapter(*args)

data/lib/instrumentation/net_http.rb

@@ -40,7 +40,7 @@ module EpsagonNetHTTPExtension
     tracer.in_span(
       @address,
       attributes: attributes,
-      kind: :Client
+      kind: :client
     ) do |span|
       OpenTelemetry.propagation.http.inject(req)
 

data/lib/instrumentation/rails.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'opentelemetry'
+require 'rails'
+require 'action_controller/railtie'
+
+require_relative '../util'
+
+module RackExtension
+  module_function
+
+  CURRENT_SPAN_KEY = OpenTelemetry::Context.create_key('current-span')
+
+  private_constant :CURRENT_SPAN_KEY
+
+  # Returns the current span from the current or provided context
+  #
+  # @param [optional Context] context The context to lookup the current
+  #   {Span} from. Defaults to Context.current
+  def current_span(context = nil)
+    context ||= OpenTelemetry::Context.current
+    context.value(CURRENT_SPAN_KEY) || OpenTelemetry::Trace::Span::INVALID
+  end
+
+  # Returns a context containing the span, derived from the optional parent
+  # context, or the current context if one was not provided.
+  #
+  # @param [optional Context] context The context to use as the parent for
+  #   the returned context
+  def context_with_span(span, parent_context: OpenTelemetry::Context.current)
+    parent_context.set_value(CURRENT_SPAN_KEY, span)
+  end
+
+  # Activates/deactivates the Span within the current Context, which makes the "current span"
+  # available implicitly.
+  #
+  # On exit, the Span that was active before calling this method will be reactivated.
+  #
+  # @param [Span] span the span to activate
+  # @yield [span, context] yields span and a context containing the span to the block.
+  def with_span(span)
+    OpenTelemetry::Context.with_value(CURRENT_SPAN_KEY, span) { |c, s| yield s, c }
+  end
+end
+
+module MetalPatch
+  def dispatch(name, request, response)
+    rack_span = RackExtension.current_span
+    # rack_span.name = "#{self.class.name}##{name}" if rack_span.context.valid? && !request.env['action_dispatch.exception']
+    super(name, request, response)
+  end
+end
+
+class EpsagonRailsInstrumentation < OpenTelemetry::Instrumentation::Base
+  install do |_config|
+    require_relative 'epsagon_rails_middleware'
+    ::ActionController::Metal.prepend(MetalPatch)
+  end
+
+  present do
+    defined?(::Rails)
+  end
+end

data/lib/instrumentation/sinatra.rb

@@ -26,7 +26,7 @@ class EpsagonTracerMiddleware
     attributes = {
       'operation' => env['REQUEST_METHOD'],
       'type' => 'http',
-      'http.scheme' => env['PATH_INFO'],
+      'http.scheme' => env['rack.url_scheme'],
       'http.request.path' => path,
       'http.request.headers' => request_headers
     }
@@ -48,10 +48,14 @@ class EpsagonTracerMiddleware
     tracer.in_span(
       env['HTTP_HOST'],
       attributes: attributes,
-      kind: :Server,
+      kind: :server,
       with_parent: parent_context(env)
     ) do |http_span|
-      tracer.in_span('sinatra') do |framework_span|
+      tracer.in_span(
+        env['HTTP_HOST'],
+        kind: :server,
+        attributes: { type: 'sinatra' }
+      ) do |framework_span|
         app.call(env).tap { |resp| trace_response(http_span, framework_span, env, resp) }
       end
     end
@@ -78,7 +82,7 @@ class EpsagonTracerMiddleware
     end
 
     http_span.set_attribute('http.status_code', status)
-    framework_span.set_attribute('http.route', env['sinatra.route'].split.last) if env['sinatra.route']
+    http_span.set_attribute('http.route', env['sinatra.route'].split.last) if env['sinatra.route']
     http_span.status = OpenTelemetry::Trace::Status.http_to_status(status)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epsagon
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.14
 platform: ruby
 authors:
 - Epsagon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-10 00:00:00.000000000 Z
+date: 2021-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.11.0
 - !ruby/object:Gem::Dependency
-  name: opentelemetry-sdk
+  name: opentelemetry-exporter-otlp
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.1
+        version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.1
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: opentelemetry-instrumentation-sinatra
   requirement: !ruby/object:Gem::Requirement
@@ -53,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.11.0
 - !ruby/object:Gem::Dependency
-  name: opentelemetry-exporter-otlp
+  name: opentelemetry-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.11.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.11.1
 description: 'Epsagon provides tracing to Ruby applications for the collection of
   distributed tracing and performance metrics to simplify complex architectures, eliminate
   manual work, visualize and correlate data to identify and fix problems fast.
@@ -78,9 +78,12 @@ extra_rdoc_files: []
 files:
 - lib/epsagon.rb
 - lib/instrumentation/aws_sdk.rb
+- lib/instrumentation/aws_sdk_plugin.rb
 - lib/instrumentation/epsagon_faraday_middleware.rb
+- lib/instrumentation/epsagon_rails_middleware.rb
 - lib/instrumentation/faraday.rb
 - lib/instrumentation/net_http.rb
+- lib/instrumentation/rails.rb
 - lib/instrumentation/sinatra.rb
 - lib/util.rb
 homepage: https://github.com/epsagon/epsagon-ruby