opentelemetry-instrumentation-excon 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9c9b597402f3c9c890dbb5b7b534ac4d68bc9ca39617061faecf11f1a00ca60
-  data.tar.gz: 73e820abc4c9da739c484c9229bc842eadd23d21db593c1e70be446ecae625ca
+  metadata.gz: 665fc138f916ed28ac04ad618f3763d486100fdfb728eb6f36afe5be44b91ea3
+  data.tar.gz: ab39b09837a43e659d25209960b649bd9070905f751abddd5d494e64a69b831b
 SHA512:
-  metadata.gz: 5438e5e0158b9dff3fdf28f4dfe01395a3605e94e9f0abef6b92d6cce5ef89889f674d0921e385abff95a3d20cf33106e20ba3b10a42f1a6da2ab7a6f35dc423
-  data.tar.gz: 37c38ec600c47a2a007cd11075cad33f36890c28f0b9c48ccd90bfaa282d7bfcdba2885792dc6f32b38aaa6f90ebbb37ebce43daf9f0a68cead00bd26bfafaf3
+  metadata.gz: 9aeb16c010bfee7044705d6d0a85583adfa91cb27cba4ad3cc79ba8773bd9d9edfefd8646e63d5d0724ef1c8b2051962fc606155e7f5358539cd222fdf261ba2
+  data.tar.gz: c497f7b505130661372b15f1c594e2084ba9a3696fba0f9f11ac132a3a9f84e8f30ce28079af653337bcdb4f18539c996f7afa9aed6a5a00822d3ecb7387fd6b

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Release History: opentelemetry-instrumentation-excon
 
+### v0.24.0 / 2025-08-12
+
+* ADDED: Add Excon `OTEL_SEMCONV_STABILITY_OPT_IN` environment variable [#1569](https://github.com/open-telemetry/opentelemetry-ruby-contrib/pull/1569)
+
 ### v0.23.0 / 2025-01-16
 
 * BREAKING CHANGE: Set minimum supported version to Ruby 3.1

data/README.md

@@ -48,3 +48,20 @@ The `opentelemetry-instrumentation-all` gem is distributed under the Apache 2.0
 [community-meetings]: https://github.com/open-telemetry/community#community-meetings
 [slack-channel]: https://cloud-native.slack.com/archives/C01NWKKMKMY
 [discussions-url]: https://github.com/open-telemetry/opentelemetry-ruby/discussions
+
+
+## HTTP semantic convention stability
+
+In the OpenTelemetry ecosystem, HTTP semantic conventions have now reached a stable state. However, the initial Excon instrumentation was introduced before this stability was achieved, which resulted in HTTP attributes being based on an older version of the semantic conventions.
+
+To facilitate the migration to stable semantic conventions, you can use the `OTEL_SEMCONV_STABILITY_OPT_IN` environment variable. This variable allows you to opt-in to the new stable conventions, ensuring compatibility and future-proofing your instrumentation.
+
+When setting the value for `OTEL_SEMCONV_STABILITY_OPT_IN`, you can specify which conventions you wish to adopt:
+
+- `http` - Emits the stable HTTP and networking conventions and ceases emitting the old conventions previously emitted by the instrumentation.
+- `http/dup` - Emits both the old and stable HTTP and networking conventions, enabling a phased rollout of the stable semantic conventions.
+- Default behavior (in the absence of either value) is to continue emitting the old HTTP and networking conventions the instrumentation previously emitted.
+
+During the transition from old to stable conventions, Excon instrumentation code comes in three patch versions: `dup`, `old`, and `stable`. These versions are identical except for the attributes they send. Any changes to Excon instrumentation should consider all three patches.
+
+For additional information on migration, please refer to our [documentation](https://opentelemetry.io/docs/specs/semconv/non-normative/http-migration/).

data/lib/opentelemetry/instrumentation/excon/instrumentation.rb

@@ -15,9 +15,10 @@ module OpenTelemetry
         include OpenTelemetry::Instrumentation::Concerns::UntracedHosts
 
         install do |_config|
-          require_dependencies
-          add_middleware
-          patch
+          patch_type = determine_semconv
+          send(:"require_dependencies_#{patch_type}")
+          send(:"add_middleware_#{patch_type}")
+          send(:"patch_#{patch_type}")
         end
 
         present do
@@ -28,17 +29,56 @@ module OpenTelemetry
 
         private
 
-        def require_dependencies
-          require_relative 'middlewares/tracer_middleware'
-          require_relative 'patches/socket'
+        def determine_semconv
+          stability_opt_in = ENV.fetch('OTEL_SEMCONV_STABILITY_OPT_IN', '')
+          values = stability_opt_in.split(',').map(&:strip)
+
+          if values.include?('http/dup')
+            'dup'
+          elsif values.include?('http')
+            'stable'
+          else
+            'old'
+          end
+        end
+
+        def require_dependencies_dup
+          require_relative 'middlewares/dup/tracer_middleware'
+          require_relative 'patches/dup/socket'
+        end
+
+        def require_dependencies_stable
+          require_relative 'middlewares/stable/tracer_middleware'
+          require_relative 'patches/stable/socket'
+        end
+
+        def require_dependencies_old
+          require_relative 'middlewares/old/tracer_middleware'
+          require_relative 'patches/old/socket'
+        end
+
+        def add_middleware_dup
+          ::Excon.defaults[:middlewares] = Middlewares::Dup::TracerMiddleware.around_default_stack
+        end
+
+        def add_middleware_stable
+          ::Excon.defaults[:middlewares] = Middlewares::Stable::TracerMiddleware.around_default_stack
+        end
+
+        def add_middleware_old
+          ::Excon.defaults[:middlewares] = Middlewares::Old::TracerMiddleware.around_default_stack
+        end
+
+        def patch_dup
+          ::Excon::Socket.prepend(Patches::Dup::Socket)
         end
 
-        def add_middleware
-          ::Excon.defaults[:middlewares] = Middlewares::TracerMiddleware.around_default_stack
+        def patch_stable
+          ::Excon::Socket.prepend(Patches::Stable::Socket)
         end
 
-        def patch
-          ::Excon::Socket.prepend(Patches::Socket)
+        def patch_old
+          ::Excon::Socket.prepend(Patches::Old::Socket)
         end
       end
     end

data/lib/opentelemetry/instrumentation/excon/middlewares/dup/tracer_middleware.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module Excon
+      module Middlewares
+        module Dup
+          # Excon middleware for instrumentation
+          class TracerMiddleware < ::Excon::Middleware::Base
+            HTTP_METHODS_TO_UPPERCASE = %w[connect delete get head options patch post put trace].each_with_object({}) do |method, hash|
+              uppercase_method = method.upcase
+              hash[method] = uppercase_method
+              hash[method.to_sym] = uppercase_method
+              hash[uppercase_method] = uppercase_method
+            end.freeze
+
+            HTTP_METHODS_TO_SPAN_NAMES = HTTP_METHODS_TO_UPPERCASE.values.each_with_object({}) do |uppercase_method, hash|
+              hash[uppercase_method] ||= uppercase_method
+            end.freeze
+
+            # Constant for the HTTP status range
+            HTTP_STATUS_SUCCESS_RANGE = (100..399)
+
+            def request_call(datum)
+              return @stack.request_call(datum) if untraced?(datum)
+
+              http_method = HTTP_METHODS_TO_UPPERCASE[datum[:method]]
+              cleansed_url = OpenTelemetry::Common::Utilities.cleanse_url(::Excon::Utils.request_uri(datum))
+              attributes = {
+                OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => datum[:host],
+                OpenTelemetry::SemanticConventions::Trace::HTTP_METHOD => http_method,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => datum[:scheme],
+                OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => datum[:path],
+                OpenTelemetry::SemanticConventions::Trace::HTTP_URL => cleansed_url,
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => datum[:hostname],
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => datum[:port],
+                'http.request.method' => http_method,
+                'url.scheme' => datum[:scheme],
+                'url.path' => datum[:path],
+                'url.full' => cleansed_url,
+                'server.address' => datum[:hostname],
+                'server.port' => datum[:port]
+              }
+              attributes['url.query'] = datum[:query] if datum[:query]
+              peer_service = Excon::Instrumentation.instance.config[:peer_service]
+              attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = peer_service if peer_service
+              attributes.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+              span = tracer.start_span(HTTP_METHODS_TO_SPAN_NAMES[http_method], attributes: attributes, kind: :client)
+              ctx = OpenTelemetry::Trace.context_with_span(span)
+              datum[:otel_span] = span
+              datum[:otel_token] = OpenTelemetry::Context.attach(ctx)
+              OpenTelemetry.propagation.inject(datum[:headers])
+              @stack.request_call(datum)
+            end
+
+            def response_call(datum)
+              @stack.response_call(datum).tap do |d|
+                handle_response(d)
+              end
+            end
+
+            def error_call(datum)
+              handle_response(datum)
+              @stack.error_call(datum)
+            end
+
+            # Returns a copy of the default stack with the trace middleware injected
+            def self.around_default_stack
+              ::Excon.defaults[:middlewares].dup.tap do |default_stack|
+                # If the default stack contains a version of the trace middleware already...
+                existing_trace_middleware = default_stack.find { |m| m <= TracerMiddleware }
+                default_stack.delete(existing_trace_middleware) if existing_trace_middleware
+                # Inject after the ResponseParser middleware
+                response_middleware_index = default_stack.index(::Excon::Middleware::ResponseParser).to_i
+                default_stack.insert(response_middleware_index + 1, self)
+              end
+            end
+
+            private
+
+            def handle_response(datum)
+              datum.delete(:otel_span)&.tap do |span|
+                return unless span.recording?
+
+                if datum.key?(:response)
+                  response = datum[:response]
+                  span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response[:status])
+                  span.set_attribute('http.response.status_code', response[:status])
+                  span.status = OpenTelemetry::Trace::Status.error unless HTTP_STATUS_SUCCESS_RANGE.cover?(response[:status].to_i)
+                end
+
+                if datum.key?(:error)
+                  span.status = OpenTelemetry::Trace::Status.error('Request has failed')
+                  span.record_exception(datum[:error])
+                end
+
+                span.finish
+                OpenTelemetry::Context.detach(datum.delete(:otel_token)) if datum.include?(:otel_token)
+              end
+            rescue StandardError => e
+              OpenTelemetry.handle_error(e)
+            end
+
+            def tracer
+              Excon::Instrumentation.instance.tracer
+            end
+
+            def untraced?(datum)
+              datum.key?(:otel_span) || Excon::Instrumentation.instance.untraced?(datum[:host])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/excon/middlewares/old/tracer_middleware.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module Excon
+      module Middlewares
+        module Old
+          # Excon middleware for instrumentation
+          class TracerMiddleware < ::Excon::Middleware::Base
+            HTTP_METHODS_TO_UPPERCASE = %w[connect delete get head options patch post put trace].each_with_object({}) do |method, hash|
+              uppercase_method = method.upcase
+              hash[method] = uppercase_method
+              hash[method.to_sym] = uppercase_method
+              hash[uppercase_method] = uppercase_method
+            end.freeze
+
+            HTTP_METHODS_TO_SPAN_NAMES = HTTP_METHODS_TO_UPPERCASE.values.each_with_object({}) do |uppercase_method, hash|
+              hash[uppercase_method] ||= "HTTP #{uppercase_method}"
+            end.freeze
+
+            # Constant for the HTTP status range
+            HTTP_STATUS_SUCCESS_RANGE = (100..399)
+
+            def request_call(datum)
+              return @stack.request_call(datum) if untraced?(datum)
+
+              http_method = HTTP_METHODS_TO_UPPERCASE[datum[:method]]
+              attributes = {
+                OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => datum[:host],
+                OpenTelemetry::SemanticConventions::Trace::HTTP_METHOD => http_method,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => datum[:scheme],
+                OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => datum[:path],
+                OpenTelemetry::SemanticConventions::Trace::HTTP_URL => OpenTelemetry::Common::Utilities.cleanse_url(::Excon::Utils.request_uri(datum)),
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => datum[:hostname],
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => datum[:port]
+              }
+              peer_service = Excon::Instrumentation.instance.config[:peer_service]
+              attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = peer_service if peer_service
+              attributes.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+              span = tracer.start_span(HTTP_METHODS_TO_SPAN_NAMES[http_method], attributes: attributes, kind: :client)
+              ctx = OpenTelemetry::Trace.context_with_span(span)
+              datum[:otel_span] = span
+              datum[:otel_token] = OpenTelemetry::Context.attach(ctx)
+              OpenTelemetry.propagation.inject(datum[:headers])
+              @stack.request_call(datum)
+            end
+
+            def response_call(datum)
+              @stack.response_call(datum).tap do |d|
+                handle_response(d)
+              end
+            end
+
+            def error_call(datum)
+              handle_response(datum)
+              @stack.error_call(datum)
+            end
+
+            # Returns a copy of the default stack with the trace middleware injected
+            def self.around_default_stack
+              ::Excon.defaults[:middlewares].dup.tap do |default_stack|
+                # If the default stack contains a version of the trace middleware already...
+                existing_trace_middleware = default_stack.find { |m| m <= TracerMiddleware }
+                default_stack.delete(existing_trace_middleware) if existing_trace_middleware
+                # Inject after the ResponseParser middleware
+                response_middleware_index = default_stack.index(::Excon::Middleware::ResponseParser).to_i
+                default_stack.insert(response_middleware_index + 1, self)
+              end
+            end
+
+            private
+
+            def handle_response(datum)
+              datum.delete(:otel_span)&.tap do |span|
+                return unless span.recording?
+
+                if datum.key?(:response)
+                  response = datum[:response]
+                  span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response[:status])
+                  span.status = OpenTelemetry::Trace::Status.error unless HTTP_STATUS_SUCCESS_RANGE.cover?(response[:status].to_i)
+                end
+
+                if datum.key?(:error)
+                  span.status = OpenTelemetry::Trace::Status.error('Request has failed')
+                  span.record_exception(datum[:error])
+                end
+
+                span.finish
+                OpenTelemetry::Context.detach(datum.delete(:otel_token)) if datum.include?(:otel_token)
+              end
+            rescue StandardError => e
+              OpenTelemetry.handle_error(e)
+            end
+
+            def tracer
+              Excon::Instrumentation.instance.tracer
+            end
+
+            def untraced?(datum)
+              datum.key?(:otel_span) || Excon::Instrumentation.instance.untraced?(datum[:host])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/excon/middlewares/stable/tracer_middleware.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module Excon
+      module Middlewares
+        module Stable
+          # Excon middleware for instrumentation
+          class TracerMiddleware < ::Excon::Middleware::Base
+            HTTP_METHODS_TO_UPPERCASE = %w[connect delete get head options patch post put trace].each_with_object({}) do |method, hash|
+              uppercase_method = method.upcase
+              hash[method] = uppercase_method
+              hash[method.to_sym] = uppercase_method
+              hash[uppercase_method] = uppercase_method
+            end.freeze
+
+            HTTP_METHODS_TO_SPAN_NAMES = HTTP_METHODS_TO_UPPERCASE.values.each_with_object({}) do |uppercase_method, hash|
+              hash[uppercase_method] ||= uppercase_method
+            end.freeze
+
+            # Constant for the HTTP status range
+            HTTP_STATUS_SUCCESS_RANGE = (100..399)
+
+            def request_call(datum)
+              return @stack.request_call(datum) if untraced?(datum)
+
+              http_method = HTTP_METHODS_TO_UPPERCASE[datum[:method]]
+              attributes = {
+                'http.request.method' => http_method,
+                'url.scheme' => datum[:scheme],
+                'url.path' => datum[:path],
+                'url.full' => OpenTelemetry::Common::Utilities.cleanse_url(::Excon::Utils.request_uri(datum)),
+                'server.address' => datum[:hostname],
+                'server.port' => datum[:port]
+              }
+              attributes['url.query'] = datum[:query] if datum[:query]
+              peer_service = Excon::Instrumentation.instance.config[:peer_service]
+              attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = peer_service if peer_service
+              attributes.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+              span = tracer.start_span(HTTP_METHODS_TO_SPAN_NAMES[http_method], attributes: attributes, kind: :client)
+              ctx = OpenTelemetry::Trace.context_with_span(span)
+              datum[:otel_span] = span
+              datum[:otel_token] = OpenTelemetry::Context.attach(ctx)
+              OpenTelemetry.propagation.inject(datum[:headers])
+              @stack.request_call(datum)
+            end
+
+            def response_call(datum)
+              @stack.response_call(datum).tap do |d|
+                handle_response(d)
+              end
+            end
+
+            def error_call(datum)
+              handle_response(datum)
+              @stack.error_call(datum)
+            end
+
+            # Returns a copy of the default stack with the trace middleware injected
+            def self.around_default_stack
+              ::Excon.defaults[:middlewares].dup.tap do |default_stack|
+                # If the default stack contains a version of the trace middleware already...
+                existing_trace_middleware = default_stack.find { |m| m <= TracerMiddleware }
+                default_stack.delete(existing_trace_middleware) if existing_trace_middleware
+                # Inject after the ResponseParser middleware
+                response_middleware_index = default_stack.index(::Excon::Middleware::ResponseParser).to_i
+                default_stack.insert(response_middleware_index + 1, self)
+              end
+            end
+
+            private
+
+            def handle_response(datum)
+              datum.delete(:otel_span)&.tap do |span|
+                return unless span.recording?
+
+                if datum.key?(:response)
+                  response = datum[:response]
+                  span.set_attribute('http.response.status_code', response[:status])
+                  span.status = OpenTelemetry::Trace::Status.error unless HTTP_STATUS_SUCCESS_RANGE.cover?(response[:status].to_i)
+                end
+
+                if datum.key?(:error)
+                  span.status = OpenTelemetry::Trace::Status.error('Request has failed')
+                  span.record_exception(datum[:error])
+                end
+
+                span.finish
+                OpenTelemetry::Context.detach(datum.delete(:otel_token)) if datum.include?(:otel_token)
+              end
+            rescue StandardError => e
+              OpenTelemetry.handle_error(e)
+            end
+
+            def tracer
+              Excon::Instrumentation.instance.tracer
+            end
+
+            def untraced?(datum)
+              datum.key?(:otel_span) || Excon::Instrumentation.instance.untraced?(datum[:host])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/excon/patches/dup/socket.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module Excon
+      module Patches
+        module Dup
+          # Module to prepend to an Excon Socket for instrumentation
+          module Socket
+            private
+
+            def connect
+              return super if untraced?
+
+              if @data[:proxy]
+                conn_address = @data.dig(:proxy, :hostname)
+                conn_port = @data.dig(:proxy, :port)
+              else
+                conn_address = @data[:hostname]
+                conn_port = @port
+              end
+
+              attributes = {
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => conn_address,
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => conn_port,
+                'server.address' => conn_address,
+                'server.port' => conn_port
+              }.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+
+              if is_a?(::Excon::SSLSocket) && @data[:proxy]
+                span_name = 'CONNECT'
+                span_kind = :client
+              else
+                span_name = 'connect'
+                span_kind = :internal
+              end
+
+              tracer.in_span(span_name, attributes: attributes, kind: span_kind) do
+                super
+              end
+            end
+
+            def tracer
+              Excon::Instrumentation.instance.tracer
+            end
+
+            def untraced?
+              address = if @data[:proxy]
+                          @data.dig(:proxy, :hostname)
+                        else
+                          @data[:hostname]
+                        end
+
+              Excon::Instrumentation.instance.untraced?(address)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/excon/patches/old/socket.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module Excon
+      module Patches
+        module Old
+          # Module to prepend to an Excon Socket for instrumentation
+          module Socket
+            private
+
+            def connect
+              return super if untraced?
+
+              if @data[:proxy]
+                conn_address = @data.dig(:proxy, :hostname)
+                conn_port = @data.dig(:proxy, :port)
+              else
+                conn_address = @data[:hostname]
+                conn_port = @port
+              end
+
+              attributes = { OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => conn_address, OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => conn_port }.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+
+              if is_a?(::Excon::SSLSocket) && @data[:proxy]
+                span_name = 'HTTP CONNECT'
+                span_kind = :client
+              else
+                span_name = 'connect'
+                span_kind = :internal
+              end
+
+              tracer.in_span(span_name, attributes: attributes, kind: span_kind) do
+                super
+              end
+            end
+
+            def tracer
+              Excon::Instrumentation.instance.tracer
+            end
+
+            def untraced?
+              address = if @data[:proxy]
+                          @data.dig(:proxy, :hostname)
+                        else
+                          @data[:hostname]
+                        end
+
+              Excon::Instrumentation.instance.untraced?(address)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/excon/patches/stable/socket.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module Excon
+      module Patches
+        module Stable
+          # Module to prepend to an Excon Socket for instrumentation
+          module Socket
+            private
+
+            def connect
+              return super if untraced?
+
+              if @data[:proxy]
+                conn_address = @data.dig(:proxy, :hostname)
+                conn_port = @data.dig(:proxy, :port)
+              else
+                conn_address = @data[:hostname]
+                conn_port = @port
+              end
+
+              attributes = { 'server.address' => conn_address, 'server.port' => conn_port }.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+
+              if is_a?(::Excon::SSLSocket) && @data[:proxy]
+                span_name = 'CONNECT'
+                span_kind = :client
+              else
+                span_name = 'connect'
+                span_kind = :internal
+              end
+
+              tracer.in_span(span_name, attributes: attributes, kind: span_kind) do
+                super
+              end
+            end
+
+            def tracer
+              Excon::Instrumentation.instance.tracer
+            end
+
+            def untraced?
+              address = if @data[:proxy]
+                          @data.dig(:proxy, :hostname)
+                        else
+                          @data[:hostname]
+                        end
+
+              Excon::Instrumentation.instance.untraced?(address)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@
 module OpenTelemetry
   module Instrumentation
     module Excon
-      VERSION = '0.23.0'
+      VERSION = '0.24.0'
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-instrumentation-excon
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.24.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-16 00:00:00.000000000 Z
+date: 2025-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -38,146 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.23.0
-- !ruby/object:Gem::Dependency
-  name: appraisal
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.4'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: opentelemetry-sdk
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-- !ruby/object:Gem::Dependency
-  name: opentelemetry-test-helpers
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.69.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.69.1
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.23.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.23.0
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.17.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.17.1
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.24.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.24.0
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
 description: Excon instrumentation for the OpenTelemetry framework
 email:
 - cncf-opentelemetry-contributors@lists.cncf.io
@@ -194,17 +54,21 @@ files:
 - lib/opentelemetry/instrumentation/concerns/untraced_hosts.rb
 - lib/opentelemetry/instrumentation/excon.rb
 - lib/opentelemetry/instrumentation/excon/instrumentation.rb
-- lib/opentelemetry/instrumentation/excon/middlewares/tracer_middleware.rb
-- lib/opentelemetry/instrumentation/excon/patches/socket.rb
+- lib/opentelemetry/instrumentation/excon/middlewares/dup/tracer_middleware.rb
+- lib/opentelemetry/instrumentation/excon/middlewares/old/tracer_middleware.rb
+- lib/opentelemetry/instrumentation/excon/middlewares/stable/tracer_middleware.rb
+- lib/opentelemetry/instrumentation/excon/patches/dup/socket.rb
+- lib/opentelemetry/instrumentation/excon/patches/old/socket.rb
+- lib/opentelemetry/instrumentation/excon/patches/stable/socket.rb
 - lib/opentelemetry/instrumentation/excon/version.rb
 homepage: https://github.com/open-telemetry/opentelemetry-ruby-contrib
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-excon/0.23.0/file/CHANGELOG.md
+  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-excon/0.24.0/file/CHANGELOG.md
   source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/tree/main/instrumentation/excon
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/issues
-  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-excon/0.23.0
+  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-excon/0.24.0
 post_install_message:
 rdoc_options: []
 require_paths:

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

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module Instrumentation
-    module Excon
-      module Middlewares
-        # Excon middleware for instrumentation
-        class TracerMiddleware < ::Excon::Middleware::Base
-          HTTP_METHODS_TO_UPPERCASE = %w[connect delete get head options patch post put trace].each_with_object({}) do |method, hash|
-            uppercase_method = method.upcase
-            hash[method] = uppercase_method
-            hash[method.to_sym] = uppercase_method
-            hash[uppercase_method] = uppercase_method
-          end.freeze
-
-          HTTP_METHODS_TO_SPAN_NAMES = HTTP_METHODS_TO_UPPERCASE.values.each_with_object({}) do |uppercase_method, hash|
-            hash[uppercase_method] ||= "HTTP #{uppercase_method}"
-          end.freeze
-
-          # Constant for the HTTP status range
-          HTTP_STATUS_SUCCESS_RANGE = (100..399)
-
-          def request_call(datum)
-            return @stack.request_call(datum) if untraced?(datum)
-
-            http_method = HTTP_METHODS_TO_UPPERCASE[datum[:method]]
-            attributes = {
-              OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => datum[:host],
-              OpenTelemetry::SemanticConventions::Trace::HTTP_METHOD => http_method,
-              OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => datum[:scheme],
-              OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => datum[:path],
-              OpenTelemetry::SemanticConventions::Trace::HTTP_URL => OpenTelemetry::Common::Utilities.cleanse_url(::Excon::Utils.request_uri(datum)),
-              OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => datum[:hostname],
-              OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => datum[:port]
-            }
-            peer_service = Excon::Instrumentation.instance.config[:peer_service]
-            attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = peer_service if peer_service
-            attributes.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
-            span = tracer.start_span(HTTP_METHODS_TO_SPAN_NAMES[http_method], attributes: attributes, kind: :client)
-            ctx = OpenTelemetry::Trace.context_with_span(span)
-            datum[:otel_span] = span
-            datum[:otel_token] = OpenTelemetry::Context.attach(ctx)
-            OpenTelemetry.propagation.inject(datum[:headers])
-            @stack.request_call(datum)
-          end
-
-          def response_call(datum)
-            @stack.response_call(datum).tap do |d|
-              handle_response(d)
-            end
-          end
-
-          def error_call(datum)
-            handle_response(datum)
-            @stack.error_call(datum)
-          end
-
-          # Returns a copy of the default stack with the trace middleware injected
-          def self.around_default_stack
-            ::Excon.defaults[:middlewares].dup.tap do |default_stack|
-              # If the default stack contains a version of the trace middleware already...
-              existing_trace_middleware = default_stack.find { |m| m <= TracerMiddleware }
-              default_stack.delete(existing_trace_middleware) if existing_trace_middleware
-              # Inject after the ResponseParser middleware
-              response_middleware_index = default_stack.index(::Excon::Middleware::ResponseParser).to_i
-              default_stack.insert(response_middleware_index + 1, self)
-            end
-          end
-
-          private
-
-          def handle_response(datum)
-            datum.delete(:otel_span)&.tap do |span|
-              return unless span.recording?
-
-              if datum.key?(:response)
-                response = datum[:response]
-                span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response[:status])
-                span.status = OpenTelemetry::Trace::Status.error unless HTTP_STATUS_SUCCESS_RANGE.cover?(response[:status].to_i)
-              end
-
-              if datum.key?(:error)
-                span.status = OpenTelemetry::Trace::Status.error('Request has failed')
-                span.record_exception(datum[:error])
-              end
-
-              span.finish
-              OpenTelemetry::Context.detach(datum.delete(:otel_token)) if datum.include?(:otel_token)
-            end
-          rescue StandardError => e
-            OpenTelemetry.handle_error(e)
-          end
-
-          def tracer
-            Excon::Instrumentation.instance.tracer
-          end
-
-          def untraced?(datum)
-            datum.key?(:otel_span) || Excon::Instrumentation.instance.untraced?(datum[:host])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/opentelemetry/instrumentation/excon/patches/socket.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module Instrumentation
-    module Excon
-      module Patches
-        # Module to prepend to an Excon Socket for instrumentation
-        module Socket
-          private
-
-          def connect
-            return super if untraced?
-
-            if @data[:proxy]
-              conn_address = @data.dig(:proxy, :hostname)
-              conn_port = @data.dig(:proxy, :port)
-            else
-              conn_address = @data[:hostname]
-              conn_port = @port
-            end
-
-            attributes = { OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => conn_address, OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => conn_port }.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
-
-            if is_a?(::Excon::SSLSocket) && @data[:proxy]
-              span_name = 'HTTP CONNECT'
-              span_kind = :client
-            else
-              span_name = 'connect'
-              span_kind = :internal
-            end
-
-            tracer.in_span(span_name, attributes: attributes, kind: span_kind) do
-              super
-            end
-          end
-
-          def tracer
-            Excon::Instrumentation.instance.tracer
-          end
-
-          def untraced?
-            address = if @data[:proxy]
-                        @data.dig(:proxy, :hostname)
-                      else
-                        @data[:hostname]
-                      end
-
-            Excon::Instrumentation.instance.untraced?(address)
-          end
-        end
-      end
-    end
-  end
-end