epsagon 0.0.11 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab0dc77590ae9d619fa9dc901ce8af447cfa4555b3e4e2de648952add1604043
-  data.tar.gz: ba0e5a0589ac967734b3019e229031a345577cc44518d876228238011f3bd2a4
+  metadata.gz: 808ee2781331d674be9e661fdb982402a9fa118a7e530226334dac758ce80dbb
+  data.tar.gz: 370aad1ea87d60e10ffa0b0c6777951c290aaacb2074a6556b6b77a41f9606d3
 SHA512:
-  metadata.gz: d383f183f674c601ef695e5b47adcaa770e8d9d6cfbe22d922b4e8785dc2b6f5c677ec0abfaab7c01df880afabe8b3c0395ffc076ff67fe3393ecc06f8a37cd5
-  data.tar.gz: 895b8b35143b0c232e4e3611ddf32652163a191f4d58af3283101af3f2f107f396be765931c3734f5f3aebe6cf2ec4f2d19d561b4cc033286cc1a33b4f373fd2
+  metadata.gz: 223f608c05ddf216c1db46709d234604af81dca746fe16d5c4f24e89618450313c6e8a972f35fa2c2f5c6aa4b5811cd97e638d625dde9a1d5b0bc9a00575cf92
+  data.tar.gz: 5317d3432c01890de86919a5415322ed151002d12058027fa890cffa34ee32818d3e87e1d4484b5317aa1ab7c9047bf9347c2d5cf71e5718791ac6766e0163eb

data/lib/epsagon.rb

@@ -10,19 +10,22 @@ 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
 
@@ -41,14 +44,15 @@ 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(
         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(
@@ -64,7 +68,6 @@ module Epsagon
       )
     end
   end
-
 end
 
 # monkey patch to include epsagon confs

data/lib/instrumentation/aws_sdk_plugin.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 require 'aws-sdk-core'
 require 'opentelemetry/common'
 require 'opentelemetry/sdk'
 
-def untraced
-  OpenTelemetry::Trace.with_span(OpenTelemetry::Trace::Span.new) { yield }
+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, _)
@@ -15,13 +18,13 @@ end
 # Generates Spans for all uses of AWS SDK
 class EpsagonAwsHandler < Seahorse::Client::Handler
   def call(context)
-    tracer.in_span('') do |span|
+    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.aws.operation', context.operation.name)
+          span.set_attribute('aws.operation', context.operation.name)
           span.set_attribute('aws.region', context.client.config.region)
-          span.set_attribute('aws.status_code', context.http_response.status_code)
+          span.set_attribute('http.status_code', context.http_response.status_code)
         end
       end
     end
@@ -30,4 +33,4 @@ class EpsagonAwsHandler < Seahorse::Client::Handler
   def tracer
     EpsagonAwsSdkInstrumentation.instance.tracer
   end
-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
     }
@@ -51,7 +51,11 @@ class EpsagonTracerMiddleware
       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.11
+  version: 0.0.16
 platform: ruby
 authors:
 - Epsagon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-12 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.
@@ -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