opentelemetry-instrumentation-httpx 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b345154080244595e374a9c5c73dc2bb6a3d3772c9e689aff17197d5d2745f00
-  data.tar.gz: b2b03b233c59c2291e429a95838f2e7bbbf23a28374784f9bd969e3ec201a589
+  metadata.gz: 7f74f31524d99c5a0565edf84892292d068322376584c58b7dc4aabbdea724fd
+  data.tar.gz: 74cdecfb4c9c7a7e3fe0164ce3977d53e33d4fa96c140265629b401f1e0dce77
 SHA512:
-  metadata.gz: fe41c4e43b96bef2caaf39830ab4a7d14ffb0ec5955f96fd71d3bb6039c06d74d9bd7fb5b8a7c547bb692a47d0e1b011fa42ea46ab76e24f705f12fe2f212c58
-  data.tar.gz: ac11915108072d027abe9383e0eb4cccba42b9dd891772f4f93dd4dcfc87c261918c37447357c999bc49a80b0583dfacabd8ae404075a04b40c498032a2fd711
+  metadata.gz: 7f78e75c32d2fd6df5635ffac615ff7fdf7ff987b9ad93970d32d171887184ca2652f081569d843705dd45f715c6a08a592ef461186f02b1c610045a5ffabe11
+  data.tar.gz: efa536643cab0d4d878acb262d62ab2936bb0ce82e70368d2bd7c6367a2781afe327eedfaafb08fa6df1e5f4cb91eb63763008f416698b1130d8b834902e57df

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Release History: opentelemetry-instrumentation-httpx
 
+### v0.6.1 / 2026-02-27
+
+* FIXED: Httpx support to ~> 1.6 adapt to request init_time (#2030)
+
 ### v0.6.0 / 2026-01-13
 
 * ADDED: HTTP Client Semconv v1.17 Span Naming
@@ -11,7 +15,6 @@
 ### v0.5.0 / 2025-10-22
 
 * BREAKING CHANGE: Min Ruby Version 3.2
-
 * ADDED: Min Ruby Version 3.2
 
 ### v0.4.1 / 2025-09-30
@@ -33,7 +36,6 @@
 ### v0.2.0 / 2025-01-16
 
 * BREAKING CHANGE: Set minimum supported version to Ruby 3.1
-
 * ADDED: Set minimum supported version to Ruby 3.1
 
 ### v0.1.3 / 2024-11-26

data/lib/opentelemetry/instrumentation/httpx/dup/plugin.rb

@@ -8,126 +8,107 @@ module OpenTelemetry
   module Instrumentation
     module HTTPX
       module Dup
+        # Dup Plugin
         module Plugin
-          # Instruments around HTTPX's request/response lifecycle in order to generate
-          # an OTEL trace.
-          module RequestTracer
-            module_function
+          def self.load_dependencies(klass)
+            require_relative '../plugin'
+            klass.plugin(HTTPX::Plugin)
 
-            # initializes tracing on the +request+.
-            def call(request)
-              span = nil
+            HTTPX::Plugin.const_set(:RequestTracer, RequestTracer)
+          end
+        end
 
-              # request objects are reused, when already buffered requests get rerouted to a different
-              # connection due to connection issues, or when they already got a response, but need to
-              # be retried. In such situations, the original span needs to be extended for the former,
-              # while a new is required for the latter.
-              request.on(:idle) do
-                span = nil
-              end
-              # the span is initialized when the request is buffered in the parser, which is the closest
-              # one gets to actually sending the request.
-              request.on(:headers) do
-                next if span
+        # Instruments around HTTPX's request/response lifecycle in order to generate
+        # an OTEL trace.
+        module RequestTracer
+          extend self
 
-                span = initialize_span(request)
-              end
+          # initializes tracing on the +request+.
+          def call(request)
+            span = nil
 
-              request.on(:response) do |response|
-                unless span
-                  next unless response.is_a?(::HTTPX::ErrorResponse) && response.error.respond_to?(:connection)
+            # request objects are reused, when already buffered requests get rerouted to a different
+            # connection due to connection issues, or when they already got a response, but need to
+            # be retried. In such situations, the original span needs to be extended for the former,
+            # while a new is required for the latter.
+            request.on(:idle) do
+              span = nil
+            end
+            # the span is initialized when the request is buffered in the parser, which is the closest
+            # one gets to actually sending the request.
+            request.on(:headers) do
+              next if span
 
-                  # handles the case when the +error+ happened during name resolution, which means
-                  # that the tracing start point hasn't been triggered yet; in such cases, the approximate
-                  # initial resolving time is collected from the connection, and used as span start time,
-                  # and the tracing object in inserted before the on response callback is called.
-                  span = initialize_span(request, response.error.connection.init_time)
+              span = initialize_span(request)
+            end
 
-                end
+            request.on(:response) do |response|
+              span = initialize_span(request, request.init_time) if !span && request.init_time
 
-                finish(response, span)
-              end
+              finish(response, span)
             end
+          end
 
-            def finish(response, span)
-              if response.is_a?(::HTTPX::ErrorResponse)
-                span.record_exception(response.error)
-                span.status = Trace::Status.error(response.error.to_s)
-              else
-                span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response.status)
-                span.set_attribute('http.response.status_code', response.status)
-
-                if response.status.between?(400, 599)
-                  err = ::HTTPX::HTTPError.new(response)
-                  span.record_exception(err)
-                  span.status = Trace::Status.error(err.to_s)
-                end
-              end
+          private
 
-              span.finish
-            end
+          def finish(response, span)
+            if response.is_a?(::HTTPX::ErrorResponse)
+              span.record_exception(response.error)
+              span.status = Trace::Status.error(response.error.to_s)
+            else
+              span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response.status)
+              span.set_attribute('http.response.status_code', response.status)
 
-            # return a span initialized with the +@request+ state.
-            def initialize_span(request, start_time = ::Time.now)
-              verb = request.verb
-              uri = request.uri
-
-              span_data = HttpHelper.span_attrs_for_dup(verb)
-
-              config = HTTPX::Instrumentation.instance.config
-
-              attributes = {
-                OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => uri.host,
-                OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => uri.scheme,
-                OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => uri.path,
-                OpenTelemetry::SemanticConventions::Trace::HTTP_URL => "#{uri.scheme}://#{uri.host}",
-                OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => uri.host,
-                OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => uri.port,
-                'url.scheme' => uri.scheme,
-                'url.path' => uri.path,
-                'url.full' => "#{uri.scheme}://#{uri.host}",
-                'server.address' => uri.host,
-                'server.port' => uri.port
-              }
-
-              attributes['url.query'] = uri.query unless uri.query.nil?
-              attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
-              attributes.merge!(span_data.attributes)
-
-              span = tracer.start_span(span_data.span_name, attributes: attributes, kind: :client, start_timestamp: start_time)
-
-              OpenTelemetry::Trace.with_span(span) do
-                OpenTelemetry.propagation.inject(request.headers)
+              if response.status.between?(400, 599)
+                err = ::HTTPX::HTTPError.new(response)
+                span.record_exception(err)
+                span.status = Trace::Status.error(err.to_s)
               end
-
-              span
-            rescue StandardError => e
-              OpenTelemetry.handle_error(exception: e)
             end
 
-            def tracer
-              HTTPX::Instrumentation.instance.tracer
-            end
+            span.finish
           end
 
-          # Request patch to initiate the trace on initialization.
-          module RequestMethods
-            def initialize(*)
-              super
-
-              RequestTracer.call(self)
+          # return a span initialized with the +@request+ state.
+          def initialize_span(request, start_time = ::Time.now)
+            verb = request.verb
+            uri = request.uri
+
+            span_data = HttpHelper.span_attrs_for_dup(verb)
+
+            config = HTTPX::Instrumentation.instance.config
+
+            attributes = {
+              OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => uri.host,
+              OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => uri.scheme,
+              OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => uri.path,
+              OpenTelemetry::SemanticConventions::Trace::HTTP_URL => "#{uri.scheme}://#{uri.host}",
+              OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => uri.host,
+              OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => uri.port,
+              'url.scheme' => uri.scheme,
+              'url.path' => uri.path,
+              'url.full' => "#{uri.scheme}://#{uri.host}",
+              'server.address' => uri.host,
+              'server.port' => uri.port
+            }
+
+            attributes['url.query'] = uri.query unless uri.query.nil?
+            attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
+            attributes.merge!(span_data.attributes)
+
+            span = tracer.start_span(span_data.span_name, attributes: attributes, kind: :client, start_timestamp: start_time)
+
+            OpenTelemetry::Trace.with_span(span) do
+              OpenTelemetry.propagation.inject(request.headers)
             end
-          end
-
-          # Connection patch to start monitoring on initialization.
-          module ConnectionMethods
-            attr_reader :init_time
 
-            def initialize(*)
-              super
+            span
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          end
 
-              @init_time = ::Time.now
-            end
+          def tracer
+            HTTPX::Instrumentation.instance.tracer
           end
         end
       end

data/lib/opentelemetry/instrumentation/httpx/instrumentation.rb

@@ -16,7 +16,7 @@ module OpenTelemetry
         end
 
         compatible do
-          Gem::Version.new(::HTTPX::VERSION) >= Gem::Version.new('0.24.7')
+          Gem::Version.new(::HTTPX::VERSION) >= Gem::Version.new('1.6.0')
         end
 
         present do

data/lib/opentelemetry/instrumentation/httpx/old/plugin.rb

@@ -8,119 +8,100 @@ module OpenTelemetry
   module Instrumentation
     module HTTPX
       module Old
+        # Old Plugin
         module Plugin
-          # Instruments around HTTPX's request/response lifecycle in order to generate
-          # an OTEL trace.
-          module RequestTracer
-            module_function
+          def self.load_dependencies(klass)
+            require_relative '../plugin'
+            klass.plugin(HTTPX::Plugin)
 
-            # initializes tracing on the +request+.
-            def call(request)
-              span = nil
-
-              # request objects are reused, when already buffered requests get rerouted to a different
-              # connection due to connection issues, or when they already got a response, but need to
-              # be retried. In such situations, the original span needs to be extended for the former,
-              # while a new is required for the latter.
-              request.on(:idle) do
-                span = nil
-              end
-              # the span is initialized when the request is buffered in the parser, which is the closest
-              # one gets to actually sending the request.
-              request.on(:headers) do
-                next if span
-
-                span = initialize_span(request)
-              end
+            HTTPX::Plugin.const_set(:RequestTracer, RequestTracer)
+          end
+        end
 
-              request.on(:response) do |response|
-                unless span
-                  next unless response.is_a?(::HTTPX::ErrorResponse) && response.error.respond_to?(:connection)
+        # Instruments around HTTPX's request/response lifecycle in order to generate
+        # an OTEL trace.
+        module RequestTracer
+          extend self
 
-                  # handles the case when the +error+ happened during name resolution, which means
-                  # that the tracing start point hasn't been triggered yet; in such cases, the approximate
-                  # initial resolving time is collected from the connection, and used as span start time,
-                  # and the tracing object in inserted before the on response callback is called.
-                  span = initialize_span(request, response.error.connection.init_time)
+          # initializes tracing on the +request+.
+          def call(request)
+            span = nil
 
-                end
+            # request objects are reused, when already buffered requests get rerouted to a different
+            # connection due to connection issues, or when they already got a response, but need to
+            # be retried. In such situations, the original span needs to be extended for the former,
+            # while a new is required for the latter.
+            request.on(:idle) do
+              span = nil
+            end
+            # the span is initialized when the request is buffered in the parser, which is the closest
+            # one gets to actually sending the request.
+            request.on(:headers) do
+              next if span
 
-                finish(response, span)
-              end
+              span = initialize_span(request)
             end
 
-            def finish(response, span)
-              if response.is_a?(::HTTPX::ErrorResponse)
-                span.record_exception(response.error)
-                span.status = Trace::Status.error(response.error.to_s)
-              else
-                span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response.status)
-
-                if response.status.between?(400, 599)
-                  err = ::HTTPX::HTTPError.new(response)
-                  span.record_exception(err)
-                  span.status = Trace::Status.error(err.to_s)
-                end
-              end
+            request.on(:response) do |response|
+              span = initialize_span(request, request.init_time) if !span && request.init_time
 
-              span.finish
+              finish(response, span)
             end
+          end
 
-            # return a span initialized with the +@request+ state.
-            def initialize_span(request, start_time = ::Time.now)
-              verb = request.verb
-              uri = request.uri
+          private
 
-              span_data = HttpHelper.span_attrs_for_old(verb)
+          def finish(response, span)
+            if response.is_a?(::HTTPX::ErrorResponse)
+              span.record_exception(response.error)
+              span.status = Trace::Status.error(response.error.to_s)
+            else
+              span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response.status)
 
-              config = HTTPX::Instrumentation.instance.config
+              if response.status.between?(400, 599)
+                err = ::HTTPX::HTTPError.new(response)
+                span.record_exception(err)
+                span.status = Trace::Status.error(err.to_s)
+              end
+            end
 
-              attributes = {
-                OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => uri.host,
-                OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => uri.scheme,
-                OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => uri.path,
-                OpenTelemetry::SemanticConventions::Trace::HTTP_URL => "#{uri.scheme}://#{uri.host}",
-                OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => uri.host,
-                OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => uri.port
-              }
+            span.finish
+          end
 
-              attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
-              attributes.merge!(span_data.attributes)
+          # return a span initialized with the +@request+ state.
+          def initialize_span(request, start_time = ::Time.now)
+            verb = request.verb
+            uri = request.uri
 
-              span = tracer.start_span(span_data.span_name, attributes: attributes, kind: :client, start_timestamp: start_time)
+            span_data = HttpHelper.span_attrs_for_old(verb)
 
-              OpenTelemetry::Trace.with_span(span) do
-                OpenTelemetry.propagation.inject(request.headers)
-              end
+            config = HTTPX::Instrumentation.instance.config
 
-              span
-            rescue StandardError => e
-              OpenTelemetry.handle_error(exception: e)
-            end
+            attributes = {
+              OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => uri.host,
+              OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => uri.scheme,
+              OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => uri.path,
+              OpenTelemetry::SemanticConventions::Trace::HTTP_URL => "#{uri.scheme}://#{uri.host}",
+              OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => uri.host,
+              OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => uri.port
+            }
 
-            def tracer
-              HTTPX::Instrumentation.instance.tracer
-            end
-          end
+            attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
+            attributes.merge!(span_data.attributes)
 
-          # Request patch to initiate the trace on initialization.
-          module RequestMethods
-            def initialize(*)
-              super
+            span = tracer.start_span(span_data.span_name, attributes: attributes, kind: :client, start_timestamp: start_time)
 
-              RequestTracer.call(self)
+            OpenTelemetry::Trace.with_span(span) do
+              OpenTelemetry.propagation.inject(request.headers)
             end
-          end
-
-          # Connection patch to start monitoring on initialization.
-          module ConnectionMethods
-            attr_reader :init_time
 
-            def initialize(*)
-              super
+            span
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          end
 
-              @init_time = ::Time.now
-            end
+          def tracer
+            HTTPX::Instrumentation.instance.tracer
           end
         end
       end

data/lib/opentelemetry/instrumentation/httpx/plugin.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module HTTPX
+      # Base Plugin
+      module Plugin
+        # Request patch to initiate the trace on initialization.
+        module RequestMethods
+          attr_accessor :init_time
+
+          # intercepts request initialization to inject the tracing logic.
+          def initialize(*)
+            super
+
+            @init_time = nil
+
+            RequestTracer.call(self)
+          end
+
+          def response=(*)
+            # init_time should be set when it's send to a connection.
+            # However, there are situations where connection initialization fails.
+            # Example is the :ssrf_filter plugin, which raises an error on
+            # initialize if the host is an IP which matches against the known set.
+            # in such cases, we'll just set here right here.
+            @init_time ||= ::Time.now
+
+            super
+          end
+        end
+
+        # Connection mixin
+        module ConnectionMethods
+          def initialize(*)
+            super
+
+            @init_time = ::Time.now
+          end
+
+          def send(request)
+            request.init_time ||= @init_time
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/httpx/stable/plugin.rb

@@ -8,118 +8,99 @@ module OpenTelemetry
   module Instrumentation
     module HTTPX
       module Stable
+        # Stable Plugin
         module Plugin
-          # Instruments around HTTPX's request/response lifecycle in order to generate
-          # an OTEL trace.
-          module RequestTracer
-            module_function
+          def self.load_dependencies(klass)
+            require_relative '../plugin'
+            klass.plugin(HTTPX::Plugin)
 
-            # initializes tracing on the +request+.
-            def call(request)
-              span = nil
-
-              # request objects are reused, when already buffered requests get rerouted to a different
-              # connection due to connection issues, or when they already got a response, but need to
-              # be retried. In such situations, the original span needs to be extended for the former,
-              # while a new is required for the latter.
-              request.on(:idle) do
-                span = nil
-              end
-              # the span is initialized when the request is buffered in the parser, which is the closest
-              # one gets to actually sending the request.
-              request.on(:headers) do
-                next if span
-
-                span = initialize_span(request)
-              end
-
-              request.on(:response) do |response|
-                unless span
-                  next unless response.is_a?(::HTTPX::ErrorResponse) && response.error.respond_to?(:connection)
+            HTTPX::Plugin.const_set(:RequestTracer, RequestTracer)
+          end
+        end
 
-                  # handles the case when the +error+ happened during name resolution, which means
-                  # that the tracing start point hasn't been triggered yet; in such cases, the approximate
-                  # initial resolving time is collected from the connection, and used as span start time,
-                  # and the tracing object in inserted before the on response callback is called.
-                  span = initialize_span(request, response.error.connection.init_time)
+        # Instruments around HTTPX's request/response lifecycle in order to generate
+        # an OTEL trace.
+        module RequestTracer
+          extend self
 
-                end
+          # initializes tracing on the +request+.
+          def call(request)
+            span = nil
 
-                finish(response, span)
-              end
+            # request objects are reused, when already buffered requests get rerouted to a different
+            # connection due to connection issues, or when they already got a response, but need to
+            # be retried. In such situations, the original span needs to be extended for the former,
+            # while a new is required for the latter.
+            request.on(:idle) do
+              span = nil
             end
+            # the span is initialized when the request is buffered in the parser, which is the closest
+            # one gets to actually sending the request.
+            request.on(:headers) do
+              next if span
 
-            def finish(response, span)
-              if response.is_a?(::HTTPX::ErrorResponse)
-                span.record_exception(response.error)
-                span.status = Trace::Status.error(response.error.to_s)
-              else
-                span.set_attribute('http.response.status_code', response.status)
-
-                if response.status.between?(400, 599)
-                  err = ::HTTPX::HTTPError.new(response)
-                  span.record_exception(err)
-                  span.status = Trace::Status.error(err.to_s)
-                end
-              end
-
-              span.finish
+              span = initialize_span(request)
             end
 
-            # return a span initialized with the +@request+ state.
-            def initialize_span(request, start_time = ::Time.now)
-              verb = request.verb
-              uri = request.uri
+            request.on(:response) do |response|
+              span = initialize_span(request, request.init_time) if !span && request.init_time
 
-              span_data = HttpHelper.span_attrs_for_stable(verb)
-
-              config = HTTPX::Instrumentation.instance.config
+              finish(response, span)
+            end
+          end
 
-              attributes = {
-                'url.scheme' => uri.scheme,
-                'url.path' => uri.path,
-                'url.full' => "#{uri.scheme}://#{uri.host}",
-                'server.address' => uri.host,
-                'server.port' => uri.port
-              }
-              attributes['url.query'] = uri.query unless uri.query.nil?
-              attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
-              attributes.merge!(span_data.attributes)
+          private
 
-              span = tracer.start_span(span_data.span_name, attributes: attributes, kind: :client, start_timestamp: start_time)
+          def finish(response, span)
+            if response.is_a?(::HTTPX::ErrorResponse)
+              span.record_exception(response.error)
+              span.status = Trace::Status.error(response.error.to_s)
+            else
+              span.set_attribute('http.response.status_code', response.status)
 
-              OpenTelemetry::Trace.with_span(span) do
-                OpenTelemetry.propagation.inject(request.headers)
+              if response.status.between?(400, 599)
+                err = ::HTTPX::HTTPError.new(response)
+                span.record_exception(err)
+                span.status = Trace::Status.error(err.to_s)
               end
-
-              span
-            rescue StandardError => e
-              OpenTelemetry.handle_error(exception: e)
             end
 
-            def tracer
-              HTTPX::Instrumentation.instance.tracer
-            end
+            span.finish
           end
 
-          # Request patch to initiate the trace on initialization.
-          module RequestMethods
-            def initialize(*)
-              super
+          # return a span initialized with the +@request+ state.
+          def initialize_span(request, start_time = ::Time.now)
+            verb = request.verb
+            uri = request.uri
 
-              RequestTracer.call(self)
-            end
-          end
+            span_data = HttpHelper.span_attrs_for_stable(verb)
+
+            config = HTTPX::Instrumentation.instance.config
 
-          # Connection patch to start monitoring on initialization.
-          module ConnectionMethods
-            attr_reader :init_time
+            attributes = {
+              'url.scheme' => uri.scheme,
+              'url.path' => uri.path,
+              'url.full' => "#{uri.scheme}://#{uri.host}",
+              'server.address' => uri.host,
+              'server.port' => uri.port
+            }
+            attributes['url.query'] = uri.query unless uri.query.nil?
+            attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
+            attributes.merge!(span_data.attributes)
 
-            def initialize(*)
-              super
+            span = tracer.start_span(span_data.span_name, attributes: attributes, kind: :client, start_timestamp: start_time)
 
-              @init_time = ::Time.now
+            OpenTelemetry::Trace.with_span(span) do
+              OpenTelemetry.propagation.inject(request.headers)
             end
+
+            span
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          end
+
+          def tracer
+            HTTPX::Instrumentation.instance.tracer
           end
         end
       end

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

@@ -7,7 +7,7 @@
 module OpenTelemetry
   module Instrumentation
     module HTTPX
-      VERSION = '0.6.0'
+      VERSION = '0.6.1'
     end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-instrumentation-httpx
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - OpenTelemetry Authors
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-instrumentation-base
@@ -42,17 +41,17 @@ files:
 - lib/opentelemetry/instrumentation/httpx/http_helper.rb
 - lib/opentelemetry/instrumentation/httpx/instrumentation.rb
 - lib/opentelemetry/instrumentation/httpx/old/plugin.rb
+- lib/opentelemetry/instrumentation/httpx/plugin.rb
 - lib/opentelemetry/instrumentation/httpx/stable/plugin.rb
 - lib/opentelemetry/instrumentation/httpx/version.rb
 homepage: https://github.com/open-telemetry/opentelemetry-ruby-contrib
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-httpx/0.6.0/file/CHANGELOG.md
+  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-httpx/0.6.1/file/CHANGELOG.md
   source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/tree/main/instrumentation/http
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/issues
-  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-httpx/0.6.0
-post_install_message:
+  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-httpx/0.6.1
 rdoc_options: []
 require_paths:
 - lib
@@ -67,8 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: HTTPX instrumentation for the OpenTelemetry framework
 test_files: []