connectrpc-otel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2afdf1c6291bd39d2b2cd5c63ca15b5cd9cf60a87484715a931857daf1808342
+  data.tar.gz: 5983b85e156b331cb2ed65e235ae813dd69571865b55df69a747598d74e52723
+SHA512:
+  metadata.gz: 816c7a986f4ca1df39040b262b57ec3337e2cf80f6404f66697d909eb0ce78cca3ca4fd657858474a272e73188814d4c3fcd0b2ff975125e55b6b96eea807ea0
+  data.tar.gz: a82429640248474cf3d9ab41b8805f7e8892109749054cb4d052d314bae4505852cb270b7eca6f975a5123fcb36f1762fbc88a2754692b996016d83aeeaab63d

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jim Myhrberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,194 @@
+# connectrpc-otel
+
+Optional, experimental OpenTelemetry traces for Connect unary/streaming, native
+gRPC and server gRPC-Web RPCs. The only runtime dependencies are
+`connectrpc ~> 0.1.0` and `opentelemetry-api >= 1.11.1, < 2`.
+Core and the HTTP/framework packages do not depend on OpenTelemetry.
+
+```ruby
+require "connectrpc/otel"
+
+subscriber = ConnectRPC::OTel::Subscriber.new(
+  tracer_provider: application_tracer_provider,
+  request_metadata: ["x-request-id"], response_metadata: ["x-region"]
+)
+instrumentation = ConnectRPC::Instrumentation.new(
+  subscribers: [subscriber], on_error: ->(error) { application_logger.warn(error.class.name) }
+)
+# Pass instrumentation: instrumentation to both ConnectRPC::Client.new and
+# ConnectRPC::Server.new. Their other options and generated callers are unchanged.
+```
+
+The application owns its SDK, sampling, processors and exporters. Requiring
+`connectrpc/otel` never loads or configures an SDK/exporter, replaces global
+providers/propagators, or creates network clients. The default tracer provider is
+the application's OpenTelemetry provider. An explicit W3C trace-context plus
+baggage propagator is used by default, including when the global propagator is
+no-op. Pass `propagator:` to select another application propagator. Span finish
+invokes application-owned processors synchronously; a synchronous exporter can
+block the calling thread/reactor. This package makes no nonblocking guarantee.
+
+See the [supported 0.x contract](../../docs/support.md) for the target support
+profile, matched package versions, compatibility policy and adoption gates.
+
+## Spans and privacy
+
+The adapter emits one CLIENT or SERVER span for each configured RPC side.
+Names for declared methods are `fully.qualified.Service/Method`.
+`rpc.system.name` is `connectrpc`, `rpc.method` is the same declared name,
+and `rpc.response.status_code` is `OK` for known success or the lower-case
+Connect error actually observed. Bare preflight/admission responses have no
+invented RPC code. Error rendering may replace an oversized error with
+`resource_exhausted`; an empty 429 has no server wire code, while clients use
+the existing HTTP fallback `unavailable`.
+
+The baseline is [Connect semantic conventions v1.44.0](https://github.com/open-telemetry/semantic-conventions/blob/v1.44.0/docs/rpc/connect-rpc.md),
+which are Development. CLIENT treats every non-OK Connect code as an error;
+SERVER treats `unknown`, `deadline_exceeded`, `unimplemented`, `internal`,
+`unavailable`, and `data_loss` as errors. Delivered `invalid_argument`, for
+example, leaves SERVER status UNSET. Independent operation failures and host
+aborts are errors. `error.type` contains bounded codes or local classifications;
+success remains UNSET. There are no automatic exception events, descriptions,
+stacks, payloads, raw URLs/queries, certificate data or arbitrary metadata.
+
+Unknown methods use span name `connectrpc` and `rpc.method=_OTHER`. This adapter
+redacts `rpc.method_original` by default. That attribute is conditionally
+required by v1.44.0 for unknown methods, so this privacy default is a specific
+conformance limitation. This is not a claim of full semantic-convention
+compliance. Instrumentation scope `connectrpc-otel` identifies its package
+version and has `connectrpc.semconv.version=1.44.0`. API 1.11.1/SDK 1.13.1 support
+scope attributes, but no tracer schema URL; none is supplied.
+
+Metadata capture requires explicit names, at most 32 per direction, each at most
+128 bytes. Values retain repeated arrays, limited to eight printable ASCII
+entries of 256 bytes each, under `connectrpc.request.metadata.<name>` and
+`connectrpc.response.metadata.<name>`. No wildcards are accepted. Selecting
+sensitive names is the application's responsibility. Baggage propagates but
+is not captured as span attributes. Request injection is staged and validated
+before merging into copied metadata; invalid injection is discarded and
+reported without changing caller metadata or protocol headers.
+
+## Processing and delivery
+
+Core observation spans timeout/metadata validation, codecs, compression,
+transport and response validation. Servers retain original failures for trusted
+neutral subscribers separately from normalized/rendered errors. The OTel
+adapter never serializes those exception objects.
+
+Custom attributes distinguish `connectrpc.processing.state`,
+`connectrpc.decision` (`processed`, `admission_rejected`, `host_rejected`) and
+`connectrpc.delivery`:
+
+- `unobserved`: direct core or Testing transport; no host-delivery evidence.
+- `body_closed`: portable Rack body close only.
+- `response_finished`: Rack's response-finished callback ran. It does not prove
+  completion of other callbacks or peer receipt. This extension takes precedence
+  over body close.
+- `completed`: native Async/Falcon full-write and cleanup boundary, including
+  Falcon HTTP/1 body callbacks. This does not promise peer/application receipt.
+- `aborted`: cancellation, reset, write failure or forced teardown.
+
+`connectrpc.processing.duration` is monotonic processing seconds. Measured
+encoded sizes appear as `connectrpc.request.wire_bytes` and
+`connectrpc.response.wire_bytes`; unknown sizes are omitted. For GET, request
+wire bytes measure the query transport payload after percent/base64 decoding
+and before inflation, independently of the empty HTTP body. Zero means measured
+empty; rejected requests before measurement remain unknown. RPC spans never
+capture request URLs, query controls or payloads. Generic HTTP instrumentation
+and host/proxy logs have their own application-owned redaction policies. Successful
+processing followed by delivery abort retains `OK` and ends ERROR.
+
+Configure native hosts through their Server. Lifecycle handles are passed
+explicitly into independent operation/setup/handler tasks. Shared connection
+readers never retain one RPC's context. Connections/setup rejected before any
+RPC exists are outside per-RPC observation. Rack consumers must close the body,
+or invoke the promised response-finished callbacks; a noncompliant consumer can
+leave a span unfinished. For native Rails controllers, override private
+`connect_instrumentation` separately from `connect_limits`. Only failures
+escaping Rails execution are captured; a successful `rescue_from` does not
+mark a successful RPC as failed. Configuration failures before Server
+construction remain outside its lifecycle.
+
+## HTTP instrumentation coexistence
+
+The SDK-backed suite tests Rack instrumentation 0.31.2 (stable middleware,
+`use_rack_events: false`) and NetHTTP instrumentation 0.29.2, with the application
+installing a W3C global propagator. Native Rails 8.1.4 is tested through its real
+controller pipeline. Generic HTTP tracing remains enabled. The observed tree is:
+application -> RPC CLIENT -> HTTP CLIENT -> RPC SERVER and HTTP SERVER as
+siblings. NetHTTP injects its HTTP CLIENT; both server integrations extract that
+serialized parent. The RPC adapter deliberately does not inspect ambient HTTP
+spans to guess a parent. In-process Testing transport also extracts serialized
+headers, even while the caller's RPC context is ambient. Other instrumentation
+combinations need their own runtime verification.
+
+## Development
+
+From the repository root use `mise run otel:setup`, `otel:test`, `otel:check`,
+`otel:build`, `otel:package`, `otel:example`, and `otel:verify`.
+The independent checksummed development bundle includes the real SDK,
+InMemorySpanExporter, HTTP instrumentations and local integration packages.
+Existing runtime closures and locks remain independent. Caches/archives are in
+`vendor/otel`, and coverage is in `coverage/otel/<Ruby>/`. Both pinned Ruby
+3.4.12 and 4.0.9 CI leaves run `otel:verify`. `scripts/integration.rb` is also a
+runnable generated-client example with a real in-memory SDK exporter.
+
+The new lock's API/SDK were released 2026-09-16. New dependencies, including
+native variants, were checked against primary RubyGems release timestamps and
+API SHA256 values before adoption, under the seven-day cooldown. The versioned
+lock preserves the eligible existing cross-package graph. Original project
+work is [MIT licensed](LICENSE), copyright 2026 Jim Myhrberg. All package
+archives pin `allowed_push_host=https://rubygems.org`; these checks never
+publish or release a gem.
+
+## Static signatures
+
+This package owns `sig/` and its discovery manifest. Add
+`library "connectrpc-otel"` to a strict Steep target with this gem installed.
+See the [RBS guide](../../docs/rbs.md) for supported APIs, extension contracts,
+partial records, runtime validation and framework-signature limits.
+`mise run rbs:check` checks application callers for this package; strict core
+source checking is a separate target from backend implementation checking.
+
+## Native streaming
+
+The core [streaming guide](../../docs/streaming.md) documents all three scoped
+Connect streaming shapes, typed generated clients/handlers, early headers,
+per-message limits and bounded ownership. Native Async/Falcon HTTP/2 supports
+both codecs and identity/gzip over h2c/TLS/mTLS. Falcon additionally serves Connect server and client
+streaming over HTTP/1.1,
+with protobuf/ProtoJSON and identity/gzip over TCP/TLS/mTLS. The standalone
+Async Host and original Async Transport remain H2-only. The explicit
+`ConnectRPC::Async::HTTP1Transport` supports Connect unary, safe GET, server
+streaming and client streaming in an application-owned reactor.
+
+The streaming guide defines Falcon's cooperative 500 ms total final-close budget
+and unchanged 100 ms / 256 KiB discard limits. Native Connect streaming clients
+have a separate one-second absolute HTTP tail policy. It applies even with a nil
+RPC deadline and can reject otherwise valid late EOF or slow intermediaries.
+
+Streaming keeps one span and fixed lifecycle state per RPC, with no per-message
+events or payload capture. The original processor retains SDK context and peer
+identity through codecs and cleanup; publication, processing and full native
+wire completion remain independent. Late application cleanup failure aborts
+delivery. Falcon H1 records its final-flush expiry before body callbacks and
+lifecycle observation; delayed callbacks consume that same 500 ms budget.
+Post-delivery discard or grace failure preserves an already completed span,
+while socket/admission ownership continues through retirement and processing join.
+
+## Native gRPC observation
+
+The actual protocol is fixed before subscriber start. gRPC uses the 1.44.0
+release-candidate conventions: `rpc.system.name=grpc`, uppercase
+`rpc.response.status_code` and code-based `error.type`, including `CANCELLED`.
+Client and Server retain the role-specific error policy above. Allowlisted gRPC
+metadata uses `rpc.request.metadata.<key>` and `rpc.response.metadata.<key>`.
+Connect keeps its existing names and lower-case codes. Unknown gRPC methods use
+span name `grpc` and `rpc.method=_OTHER`, with the same explicit privacy limit.
+Processing and delivery remain independent; successful handler processing cannot
+prove terminal HEADERS delivery. SDK configuration remains application-owned.
+
+## gRPC-Web
+
+Web calls have Call.protocol=:grpc_web before subscriber start. The project maps them to gRPC semconv 1.44.0 with rpc.system.name=grpc and bounded connectrpc.protocol=grpc_web. Status codes, metadata prefixes, error roles and original-task activation follow native gRPC.
+See the [Web guide](../../docs/grpc-web.md) for protocol, CORS, bounds and completion rules.

data/lib/connectrpc/otel/subscriber.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "version"
+
+module ConnectRPC
+  module OTel
+    SEMCONV_VERSION = "1.44.0"
+
+    class Subscriber
+      SERVER_ERRORS = %w[unknown deadline_exceeded unimplemented internal unavailable data_loss].freeze
+      private_constant :SERVER_ERRORS
+
+      def initialize(tracer_provider: OpenTelemetry.tracer_provider, propagator: nil,
+                     request_metadata: [], response_metadata: [])
+        @tracer = tracer_provider.tracer("connectrpc-otel", VERSION,
+                                         attributes: { "connectrpc.semconv.version" => SEMCONV_VERSION })
+        @propagator = propagator || OpenTelemetry::Context::Propagation::CompositeTextMapPropagator.compose_propagators(
+          [OpenTelemetry::Trace::Propagation::TraceContext.text_map_propagator,
+           OpenTelemetry::Baggage::Propagation.text_map_propagator]
+        )
+        @request_metadata = allowlist(request_metadata)
+        @response_metadata = allowlist(response_metadata)
+      end
+
+      def start(call) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        parent = if call.role == :server
+                   # Always extract serialized propagation, even for an in-process call.
+                   @propagator.extract(call.carrier, context: OpenTelemetry::Context.empty, getter: Getter.new)
+                 else
+                   OpenTelemetry::Context.current
+                 end
+        name = if call.method
+                 "#{call.method.service}/#{call.method.name}"
+               else
+                 (%i[grpc grpc_web].include?(call.protocol) ? "grpc" : "connectrpc")
+               end
+        span = @tracer.start_span(name, kind: call.role, with_parent: parent, attributes: attributes(call, name))
+        context = OpenTelemetry::Trace.context_with_span(span, parent_context: parent)
+        begin
+          @propagator.inject(call.carrier, context: context) if call.role == :client
+          Observer.new(span, context, call.role, @request_metadata, @response_metadata, call.protocol)
+        rescue Exception # rubocop:disable Lint/RescueException -- release span and preserve fatal exceptions
+          span.finish
+          raise
+        end
+      end
+
+      private
+
+      def attributes(call, name)
+        result = { "rpc.system.name" => %i[grpc grpc_web].include?(call.protocol) ? "grpc" : "connectrpc",
+                   "rpc.method" => call.method ? name : "_OTHER" }
+        result["connectrpc.protocol"] = "grpc_web" if call.protocol == :grpc_web
+        if call.role == :client
+          result["server.address"] = call.server_address if call.server_address
+          result["server.port"] = call.server_port if call.server_port
+        end
+        result
+      end
+
+      # Validate the complete allowlist transaction before retaining any configuration.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def allowlist(keys)
+        unless keys.is_a?(Array) && keys.size <= 32 && keys.all? do |key|
+                 key.is_a?(String) && key.bytesize <= 128 && /\A[0-9A-Za-z_.-]+\z/.match?(key) &&
+                 !Metadata.reserved?(key.downcase)
+               end
+          raise ArgumentError, "Metadata capture requires at most 32 explicit metadata names of at most 128 bytes"
+        end
+
+        keys.map { |key| key.downcase.freeze }.uniq.freeze
+      end
+
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      class Getter
+        def get(carrier, key) # rubocop:disable Metrics/CyclomaticComplexity
+          values = Array(carrier[key])
+          return unless values.all? { |value| value.is_a?(String) && value.ascii_only? }
+          return values.first if key == "traceparent" && values.size == 1
+          return if key == "traceparent" || values.empty?
+
+          values.join(",")
+        end
+
+        def keys(carrier) = carrier.keys
+      end
+      private_constant :Getter
+
+      class Observer
+        def initialize(span, context, role, request_keys, response_keys, protocol) # rubocop:disable Metrics/ParameterLists
+          @protocol = protocol
+          @span = span
+          @context = context
+          @role = role
+          @request_keys = request_keys
+          @response_keys = response_keys
+        end
+
+        def attach = OpenTelemetry::Context.attach(@context)
+        def detach(token) = OpenTelemetry::Context.detach(token)
+
+        def processing_finished(outcome) # rubocop:disable Metrics/AbcSize
+          @span.set_attribute("rpc.response.status_code", status_code(outcome.code)) if outcome.code
+          @span.set_attribute("http.response.status_code", outcome.http_status) if outcome.http_status
+          @span.set_attribute("connectrpc.processing.duration", outcome.duration)
+          @span.set_attribute("connectrpc.request.wire_bytes", outcome.request_bytes) if outcome.request_bytes
+          @span.set_attribute("connectrpc.response.wire_bytes", outcome.response_bytes) if outcome.response_bytes
+          capture("request", outcome.request_metadata, @request_keys)
+          capture("response", outcome.response_metadata, @response_keys)
+          error = processing_error(outcome)
+          fail_span(status_code(error)) if error
+        end
+
+        def finished(completion) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          @span.set_attribute("connectrpc.processing.state", completion.processing_state.to_s)
+          @span.set_attribute("connectrpc.decision", completion.decision.to_s)
+          @span.set_attribute("connectrpc.delivery", completion.delivery.to_s)
+          @span.set_attribute("http.response.status_code", completion.http_status) if completion.http_status
+          if completion.delivery == :aborted
+            code = completion.outcome&.code
+            type = if %i[grpc
+                         grpc_web].include?(@protocol) && code && code != "OK"
+                     status_code(code)
+                   else
+                     "delivery_aborted"
+                   end
+            fail_span(type)
+          elsif completion.decision != :processed
+            fail_span(completion.decision.to_s)
+          end
+        ensure
+          @span.finish
+        end
+
+        private
+
+        # Keep role-specific wire codes and independent operation failures in one table.
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def processing_error(outcome)
+          if outcome.code && outcome.code != "OK"
+            return outcome.code if @role == :client || SERVER_ERRORS.include?(outcome.code)
+
+            return nil
+          end
+          return "operation_failed" if outcome.error && !outcome.error.is_a?(ConnectRPC::Error)
+          return "operation_failed" if outcome.code.nil? && outcome.error
+          return "preflight_rejected" if outcome.http_status && outcome.http_status != 200 && outcome.code.nil?
+
+          nil
+        end
+
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def fail_span(type)
+          @span.set_attribute("error.type", type)
+          @span.status = OpenTelemetry::Trace::Status.error
+        end
+
+        def status_code(code)
+          return code unless %i[grpc grpc_web].include?(@protocol)
+
+          code == "canceled" ? "CANCELLED" : code.upcase
+        end
+
+        def capture(direction, metadata, keys) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          keys.each do |key|
+            values = metadata[key]
+            next unless values
+
+            values = values.first(8).filter_map do |value|
+              value.byteslice(0, 256) if value.is_a?(String) && value.ascii_only? && /\A[\x20-\x7e]*\z/.match?(value)
+            end
+            prefix = %i[grpc grpc_web].include?(@protocol) ? "rpc" : "connectrpc"
+            @span.set_attribute("#{prefix}.#{direction}.metadata.#{key}", values) unless values.empty?
+          end
+        end
+      end
+      private_constant :Observer
+    end
+  end
+end

data/lib/connectrpc/otel/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  module OTel
+    VERSION = "0.1.0" # x-release-please-version
+  end
+end

data/lib/connectrpc/otel.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "connectrpc"
+require_relative "otel/version"
+require "opentelemetry-api"
+require_relative "otel/subscriber"

data/sig/connectrpc-otel.rbs

@@ -0,0 +1,48 @@
+module ConnectRPC
+  module OTel
+    VERSION: String
+    SEMCONV_VERSION: String
+    type attributes = Hash[String, String | Integer | Float | bool | Array[String]]
+    interface _TraceFlags
+      def sampled?: () -> bool
+    end
+    interface _Tracestate
+      def empty?: () -> bool
+      def to_s: () -> String
+    end
+    # The default W3C propagator consumes these API capabilities. Id contents
+    # and lengths remain the provider's runtime responsibility.
+    interface _SpanContext
+      def valid?: () -> bool
+      def trace_id: () -> String
+      def span_id: () -> String
+      def trace_flags: () -> _TraceFlags
+      def tracestate: () -> _Tracestate
+    end
+    interface _Span
+      def context: () -> _SpanContext
+      def set_attribute: (String, String | Integer | Float | bool | Array[String]) -> void
+      def status=: (Object) -> void
+      def finish: () -> void
+    end
+    interface _Tracer
+      def start_span: (String, kind: :client | :server, with_parent: Object, attributes: attributes) -> _Span
+    end
+    interface _TracerProvider
+      def tracer: (String, String, attributes: attributes) -> _Tracer
+    end
+    interface _Getter
+      def get: (Hash[String, String | Array[String]], String) -> String?
+      def keys: (Hash[String, String | Array[String]]) -> Array[String]
+    end
+    interface _Propagator
+      def extract: (Hash[String, String | Array[String]], context: Object, getter: _Getter) -> Object
+      def inject: (Hash[String, String | Array[String]], context: Object) -> void
+    end
+    class Subscriber
+      def initialize: (?tracer_provider: _TracerProvider, ?propagator: _Propagator?, ?request_metadata: Array[String], ?response_metadata: Array[String]) -> void
+      # The adapter's observer is private and discovered by the neutral lifecycle.
+      def start: (Instrumentation::Call) -> Object?
+    end
+  end
+end

data/sig/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: connectrpc

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: connectrpc-otel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jimeh
+bindir: bin
+cert_chain: []
+date: 2026-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: connectrpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: Application-owned OpenTelemetry tracing through the ConnectRPC lifecycle.
+  Experimental.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/connectrpc/otel.rb
+- lib/connectrpc/otel/subscriber.rb
+- lib/connectrpc/otel/version.rb
+- sig/connectrpc-otel.rbs
+- sig/manifest.yaml
+homepage: https://github.com/jimeh/connectrpc-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/jimeh/connectrpc-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Optional OpenTelemetry traces for ConnectRPC unary calls
+test_files: []