opentelemetry-instrumentation-rack 0.22.1 → 0.23.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 766d30a643636adfbfb357b96dda9addc63c8cfb7e2b8ee35a893c34f4233c25
-  data.tar.gz: 790c9adba407dc6d7fd85d897dec535e862df9c55bf6f91a80f444ca43f8435f
+  metadata.gz: efa36f4ae67d3a3e2de6f92da89a95d06ec9e65ed2064ee27d797f9435260155
+  data.tar.gz: 88a07f80089ee518f2cffbc06369420ec01bd899edcef5cd3deb0ac2cafdf5e6
 SHA512:
-  metadata.gz: a1be43a42526e9b0719b6662ac66375679a5e3d4c9375832db919ced6d1f64124de7e2d5aefb50d8bede8d1285d2405379abb5c3babc96d642379976a3dcbbac
-  data.tar.gz: 701c79134f82f16c4485e084546359c76e47dfd66e9fef67da3e9c77744446650260360302458adea7a43d09562cc9f21eb6699be6ea498f63b4a3228b174eb4
+  metadata.gz: 53813669484205e7de27a9f02d63afdd3073e9668a93d1c268471dcfd71af41c0244d5b8d0b1946309cf35aa810cce6ae9cf40fc1e2b894d7c588af843c3c84f
+  data.tar.gz: b80006cc0690a53f42253146c4885fc124a9f19596309babad229fef80b420688c73f0903bf0721702f4cadae730dbb648f37cb3e8785abb54cab76c3c5a442d

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Release History: opentelemetry-instrumentation-rack
 
+### v0.23.1 / 2023-06-05
+
+* FIXED: Base config options 
+
+### v0.23.0 / 2023-04-17
+
+* BREAKING CHANGE: Remove retain_middleware_names Rack Option 
+* BREAKING CHANGE: Drop support for EoL Ruby 2.7 
+
+* ADDED: Remove retain_middleware_names Rack Option 
+* ADDED: Drop support for EoL Ruby 2.7 
+* ADDED: Use Rack::Events for instrumentation 
+
 ### v0.22.1 / 2023-01-14
 
 * DOCS: Fix gem homepage 

data/lib/opentelemetry/instrumentation/rack/instrumentation.rb

@@ -12,10 +12,8 @@ module OpenTelemetry
       # The Instrumentation class contains logic to detect and install the Rack
       # instrumentation
       class Instrumentation < OpenTelemetry::Instrumentation::Base
-        install do |config|
+        install do |_config|
           require_dependencies
-
-          retain_middleware_names if config[:retain_middleware_names]
         end
 
         present do
@@ -26,40 +24,59 @@ module OpenTelemetry
         option :allowed_response_headers, default: [],    validate: :array
         option :application,              default: nil,   validate: :callable
         option :record_frontend_span,     default: false, validate: :boolean
-        option :retain_middleware_names,  default: false, validate: :boolean
         option :untraced_endpoints,       default: [],    validate: :array
         option :url_quantization,         default: nil,   validate: :callable
         option :untraced_requests,        default: nil,   validate: :callable
         option :response_propagators,     default: [],    validate: :array
+        # This option is only valid for applicaitons using Rack 2.0 or greater
+        option :use_rack_events,          default: false, validate: :boolean
+
+        # Temporary Helper for Sinatra and ActionPack middleware to use during installation
+        #
+        # @example Default usage
+        #   Rack::Builder.new do
+        #     use *OpenTelemetry::Instrumentation::Rack::Instrumenation.instance.middleware_args
+        #     run lambda { |_arg| [200, { 'Content-Type' => 'text/plain' }, body] }
+        #   end
+        # @return [Array] consisting of a middleware and arguments used in rack builders
+        def middleware_args
+          if config.fetch(:use_rack_events, false) == true && defined?(::Rack::Events)
+            [::Rack::Events, [OpenTelemetry::Instrumentation::Rack::Middlewares::EventHandler.new]]
+          else
+            [OpenTelemetry::Instrumentation::Rack::Middlewares::TracerMiddleware]
+          end
+        end
 
         private
 
         def require_dependencies
+          require_relative 'middlewares/event_handler' if defined?(Rack::Events)
           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
+        def config_options(user_config)
+          config = super(user_config)
+          config[:allowed_rack_request_headers] = config[:allowed_request_headers].compact.each_with_object({}) do |header, memo|
+            key = header.to_s.upcase.gsub(/[-\s]/, '_')
+            case key
+            when 'CONTENT_TYPE', 'CONTENT_LENGTH'
+              memo[key] = build_attribute_name('http.request.header.', header)
+            else
+              memo["HTTP_#{key}"] = build_attribute_name('http.request.header.', header)
             end
+          end
 
-            next_middleware = next_middleware.instance_variable_defined?('@app') &&
-                              next_middleware.instance_variable_get('@app')
+          config[:allowed_rack_response_headers] = config[:allowed_response_headers].each_with_object({}) do |header, memo|
+            memo[header] = build_attribute_name('http.response.header.', header)
+            memo[header.to_s.upcase] = build_attribute_name('http.response.header.', header)
           end
+
+          config[:untraced_endpoints]&.compact!
+          config
+        end
+
+        def build_attribute_name(prefix, suffix)
+          prefix + suffix.to_s.downcase.gsub(/[-\s]/, '_')
         end
       end
     end

data/lib/opentelemetry/instrumentation/rack/middlewares/event_handler.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require_relative '../util'
+require 'opentelemetry/trace/status'
+
+module OpenTelemetry
+  module Instrumentation
+    module Rack
+      module Middlewares
+        # OTel Rack Event Handler
+        #
+        # This seeds the root context for this service with the server span as the `current_span`
+        # allowing for callers later in the stack to reference it using {OpenTelemetry::Trace.current_span}
+        #
+        # It also registers the server span in a context dedicated to this instrumentation that users may look up
+        # using {OpenTelemetry::Instrumentation::Rack.current_span}, which makes it possible for users to mutate the span,
+        # e.g. add events or update the span name like in the {ActionPack} instrumentation.
+        #
+        # @example Rack App Using BodyProxy
+        #   GLOBAL_LOGGER = Logger.new($stderr)
+        #   APP_TRACER = OpenTelemetry.tracer_provider.tracer('my-app', '1.0.0')
+        #
+        #   Rack::Builder.new do
+        #     use Rack::Events, [OpenTelemetry::Instrumentation::Rack::Middlewares::EventHandler.new]
+        #     run lambda { |_arg|
+        #       APP_TRACER.in_span('hello-world') do |_span|
+        #         body = Rack::BodyProxy.new(['hello world!']) do
+        #           rack_span = OpenTelemetry::Instrumentation::Rack.current_span
+        #           GLOBAL_LOGGER.info("otel.trace_id=#{rack_span.context.hex_trace_id} otel.span_id=#{rack_span.context.hex_span_id}")
+        #         end
+        #         [200, { 'Content-Type' => 'text/plain' }, body]
+        #       end
+        #     }
+        #   end
+        #
+        # @see Rack::Events
+        # @see OpenTelemetry::Instrumentation::Rack.current_span
+        class EventHandler
+          include ::Rack::Events::Abstract
+
+          TOKENS_KEY = 'otel.context.tokens'
+          GOOD_HTTP_STATUSES = (100..499)
+
+          # Creates a server span for this current request using the incoming parent context
+          # and registers them as the {current_span}
+          #
+          # @param [Rack::Request] The current HTTP request
+          # @param [Rack::Response] This is nil in practice
+          # @return [void]
+          def on_start(request, _)
+            return if untraced_request?(request.env)
+
+            parent_context = extract_remote_context(request)
+            span = create_span(parent_context, request)
+            request.env[TOKENS_KEY] = register_current_span(span)
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          end
+
+          # Optionally adds debugging response headers injected from {response_propagators}
+          #
+          # @param [Rack::Request] The current HTTP request
+          # @param [Rack::Response] This current HTTP response
+          # @return [void]
+          def on_commit(request, response)
+            span = OpenTelemetry::Instrumentation::Rack.current_span
+            return unless span.recording?
+
+            response_propagators&.each do |propagator|
+              propagator.inject(response.headers)
+            rescue StandardError => e
+              OpenTelemetry.handle_error(message: 'Unable to inject response propagation headers', exception: e)
+            end
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          end
+
+          # Records Unexpected Exceptions on the Rack span and set the Span Status to Error
+          #
+          # @note does nothing if the span is a non-recording span
+          # @param [Rack::Request] The current HTTP request
+          # @param [Rack::Response] The current HTTP response
+          # @param [Exception] An unxpected error raised by the application
+          def on_error(request, _, error)
+            span = OpenTelemetry::Instrumentation::Rack.current_span
+            return unless span.recording?
+
+            span.record_exception(error)
+            span.status = OpenTelemetry::Trace::Status.error
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          end
+
+          # Finishes the span making it eligible to be exported and cleans up existing contexts
+          #
+          # @note does nothing if the span is a non-recording span
+          # @param [Rack::Request] The current HTTP request
+          # @param [Rack::Response] The current HTTP response
+          def on_finish(request, response)
+            span = OpenTelemetry::Instrumentation::Rack.current_span
+            return unless span.recording?
+
+            add_response_attributes(span, response) if response
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          ensure
+            detach_contexts(request)
+          end
+
+          private
+
+          EMPTY_HASH = {}.freeze
+          def extract_request_headers(env)
+            return EMPTY_HASH if allowed_request_headers.empty?
+
+            allowed_request_headers.each_with_object({}) do |(key, value), result|
+              result[value] = env[key] if env.key?(key)
+            end
+          end
+
+          def extract_response_attributes(response)
+            attributes = { 'http.status_code' => response.status.to_i }
+            attributes.merge!(extract_response_headers(response.headers))
+            attributes
+          end
+
+          def extract_response_headers(headers)
+            return EMPTY_HASH if allowed_response_headers.empty?
+
+            allowed_response_headers.each_with_object({}) do |(key, value), result|
+              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
+
+          def untraced_request?(env)
+            return true if untraced_endpoints.include?(env['PATH_INFO'])
+            return true if untraced_requests&.call(env)
+
+            false
+          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)
+            # NOTE: dd-trace-rb has implemented 'quantization' (which lowers url cardinality)
+            #       see Datadog::Quantization::HTTP.url
+
+            if (implementation = url_quantization)
+              request_uri_or_path_info = request.env['REQUEST_URI'] || request.path_info
+              implementation.call(request_uri_or_path_info, request.env)
+            else
+              "HTTP #{request.request_method}"
+            end
+          end
+
+          def extract_remote_context(request)
+            OpenTelemetry.propagation.extract(
+              request.env,
+              getter: OpenTelemetry::Common::Propagation.rack_env_getter
+            )
+          end
+
+          def request_span_attributes(env)
+            attributes = {
+              'http.method' => env['REQUEST_METHOD'],
+              'http.host' => env['HTTP_HOST'] || 'unknown',
+              'http.scheme' => env['rack.url_scheme'],
+              'http.target' => env['QUERY_STRING'].empty? ? env['PATH_INFO'] : "#{env['PATH_INFO']}?#{env['QUERY_STRING']}"
+            }
+
+            attributes['http.user_agent'] = env['HTTP_USER_AGENT'] if env['HTTP_USER_AGENT']
+            attributes.merge!(extract_request_headers(env))
+            attributes
+          end
+
+          def detach_contexts(request)
+            request.env[TOKENS_KEY]&.reverse&.each do |token|
+              OpenTelemetry::Context.detach(token)
+              OpenTelemetry::Trace.current_span.finish
+            end
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          end
+
+          def add_response_attributes(span, response)
+            span.status = OpenTelemetry::Trace::Status.error unless GOOD_HTTP_STATUSES.include?(response.status.to_i)
+            attributes = extract_response_attributes(response)
+            span.add_attributes(attributes)
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          end
+
+          def record_frontend_span?
+            config[:record_frontend_span] == true
+          end
+
+          def untraced_endpoints
+            config[:untraced_endpoints]
+          end
+
+          def untraced_requests
+            config[:untraced_requests]
+          end
+
+          def url_quantization
+            config[:url_quantization]
+          end
+
+          def response_propagators
+            config[:response_propagators]
+          end
+
+          def allowed_request_headers
+            config[:allowed_rack_request_headers]
+          end
+
+          def allowed_response_headers
+            config[:allowed_rack_response_headers]
+          end
+
+          def tracer
+            OpenTelemetry::Instrumentation::Rack::Instrumentation.instance.tracer
+          end
+
+          def config
+            OpenTelemetry::Instrumentation::Rack::Instrumentation.instance.config
+          end
+
+          def register_current_span(span)
+            ctx = OpenTelemetry::Trace.context_with_span(span)
+            rack_ctx = OpenTelemetry::Instrumentation::Rack.context_with_span(span, parent_context: ctx)
+
+            contexts = [ctx, rack_ctx]
+            contexts.compact!
+            contexts.map { |context| OpenTelemetry::Context.attach(context) }
+          end
+
+          def create_span(parent_context, request)
+            span = tracer.start_span(
+              create_request_span_name(request),
+              with_parent: parent_context,
+              kind: :server,
+              attributes: request_span_attributes(request.env)
+            )
+            request_start_time = OpenTelemetry::Instrumentation::Rack::Util::QueueTime.get_request_start(request.env)
+            span.add_event('http.proxy.request.started', timestamp: request_start_time) unless request_start_time.nil?
+            span
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/rack/middlewares/tracer_middleware.rb

@@ -6,15 +6,13 @@
 
 require 'opentelemetry/trace/status'
 
-require_relative '../util/queue_time'
-
 module OpenTelemetry
   module Instrumentation
     module Rack
       module Middlewares
         # TracerMiddleware propagates context and instruments Rack requests
         # by way of its middleware system
-        class TracerMiddleware # rubocop:disable Metrics/ClassLength
+        class TracerMiddleware
           class << self
             def allowed_rack_request_headers
               @allowed_rack_request_headers ||= Array(config[:allowed_request_headers]).each_with_object({}) do |header, memo|

data/lib/opentelemetry/instrumentation/rack/util.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module Rack
+      # Provides utilities methods for creating Rack spans
+      module Util
+        require_relative 'util/queue_time'
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/rack/version.rb

@@ -7,7 +7,7 @@
 module OpenTelemetry
   module Instrumentation
     module Rack
-      VERSION = '0.22.1'
+      VERSION = '0.23.1'
     end
   end
 end

data/lib/opentelemetry/instrumentation/rack.rb

@@ -14,7 +14,6 @@ module OpenTelemetry
       extend self
 
       CURRENT_SPAN_KEY = Context.create_key('current-span')
-
       private_constant :CURRENT_SPAN_KEY
 
       # Returns the current span from the current or provided context
@@ -50,4 +49,5 @@ module OpenTelemetry
 end
 
 require_relative './rack/instrumentation'
+require_relative './rack/util'
 require_relative './rack/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-instrumentation-rack
 version: !ruby/object:Gem::Version
-  version: 0.22.1
+  version: 0.23.1
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-14 00:00:00.000000000 Z
+date: 2023-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.22.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.22.1
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -126,44 +126,44 @@ dependencies:
   name: opentelemetry-test-helpers
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.8
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.8
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -178,20 +178,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.41.1
+        version: 1.50.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.41.1
+        version: 1.50.2
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -263,17 +277,19 @@ files:
 - lib/opentelemetry/instrumentation.rb
 - lib/opentelemetry/instrumentation/rack.rb
 - lib/opentelemetry/instrumentation/rack/instrumentation.rb
+- lib/opentelemetry/instrumentation/rack/middlewares/event_handler.rb
 - lib/opentelemetry/instrumentation/rack/middlewares/tracer_middleware.rb
+- lib/opentelemetry/instrumentation/rack/util.rb
 - lib/opentelemetry/instrumentation/rack/util/queue_time.rb
 - lib/opentelemetry/instrumentation/rack/version.rb
 homepage: https://github.com/open-telemetry/opentelemetry-ruby-contrib
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-rack/0.22.1/file/CHANGELOG.md
+  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-rack/0.23.1/file/CHANGELOG.md
   source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/tree/main/instrumentation/rack
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/issues
-  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-rack/0.22.1
+  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-rack/0.23.1
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -282,14 +298,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.33
 signing_key: 
 specification_version: 4
 summary: Rack instrumentation for the OpenTelemetry framework