epsagon 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab0dc77590ae9d619fa9dc901ce8af447cfa4555b3e4e2de648952add1604043
-  data.tar.gz: ba0e5a0589ac967734b3019e229031a345577cc44518d876228238011f3bd2a4
+  metadata.gz: cfe4b588a7d3aeac7ea954338f6814c1b733cdacaab175b8ab63711a09adb849
+  data.tar.gz: a18b237f3e75ff45e3866a4570ad4125951480366007f0700af412254e04fd5e
 SHA512:
-  metadata.gz: d383f183f674c601ef695e5b47adcaa770e8d9d6cfbe22d922b4e8785dc2b6f5c677ec0abfaab7c01df880afabe8b3c0395ffc076ff67fe3393ecc06f8a37cd5
-  data.tar.gz: 895b8b35143b0c232e4e3611ddf32652163a191f4d58af3283101af3f2f107f396be765931c3734f5f3aebe6cf2ec4f2d19d561b4cc033286cc1a33b4f373fd2
+  metadata.gz: 4b0e7b5e44f8941fe647e69cb4f59c86ce144eef01fe7c96a035652c8fede98d2b781d59f495a852e1c0919fa5af40fe6413e2ef2c6c2b9c3b4a013b5ebef5c0
+  data.tar.gz: d67ce25f32683d501729e1715e6427881f7a89fc730030ade43ca3df05402c8277237df9fb1f38c9a4e460f21863a076903c2c8f011b715b50b56d4be3e2b549

data/lib/epsagon.rb

@@ -10,6 +10,7 @@ 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
@@ -41,6 +42,7 @@ module Epsagon
     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(

data/lib/instrumentation/epsagon_rails_middleware.rb

@@ -0,0 +1,282 @@
+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/AbcSize, 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 # rubocop:disable Metrics/ClassLength
+  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) # rubocop:disable Metrics/AbcSize
+    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('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['PATH_INFO'],
+      '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/rails.rb

@@ -0,0 +1,64 @@
+  
+require 'opentelemetry'
+require 'rails'
+require "action_controller/railtie"
+
+require_relative '../util'
+
+module RackExtension
+  extend self
+
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epsagon
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Epsagon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-12 00:00:00.000000000 Z
+date: 2021-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -80,8 +80,10 @@ files:
 - 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