spree_opentelemetry 6.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 87b0ae131588d75e378a7faa635e9ad618313efefe73cebb5ad19864518ffcb9
+  data.tar.gz: b175bc98dc74a568114db63f62052d7ce3855a775cb25a62b71bac4f48ba75e4
+SHA512:
+  metadata.gz: bbefa2928193a25801ea3d99b432a48e52d3ff5a95de592a48648b0fbf227598306ff3b54582679e94a315e57b6ed1c9a9abc4245746a3c7725d5c3e9d0b8ec7
+  data.tar.gz: 895c1a90875fb5a049c5653ddd507f51dd28f0d853fd07d172c63e7884fe3677e3340f8fc6edaac05ccd181b2217a873129f92e4905029a70bad940d0e9bdf1e

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present, Vendo Sp. z o.o., Vendo Connect Inc.
+
+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,55 @@
+# spree_opentelemetry
+
+Distributed tracing for [Spree Commerce](https://spreecommerce.org) via
+[OpenTelemetry](https://opentelemetry.io).
+
+With this gem installed, Spree exports traces as soon as the standard
+OpenTelemetry environment variables point at a collector — no code changes:
+
+```ruby
+# Gemfile
+gem 'spree_opentelemetry'
+```
+
+```bash
+OTEL_SERVICE_NAME=spree
+OTEL_EXPORTER_OTLP_ENDPOINT=http://collector:4318
+```
+
+Without an exporter configured, the gem stays dormant. `OTEL_SDK_DISABLED=true`
+is the kill switch.
+
+## What gets traced
+
+- **Framework layers** via the official Rails auto-instrumentation: HTTP
+  requests (Rack/Action Pack), database queries (Active Record), background
+  jobs (Active Job, with trace context carried across the enqueue → perform
+  boundary), mail delivery, outbound HTTP (Net::HTTP).
+- **Spree commerce layers** via Spree's own notification surface: workflow
+  runs and steps (external steps become `client` spans), extension hook
+  dispatch, event subscriber dispatch, webhook deliveries (with W3C
+  `traceparent` propagated to the receiving system), and payment gateway
+  calls.
+
+Span attributes never contain personal data — prefixed IDs, workflow/step
+names, gateway action names, and HTTP metadata only.
+
+See the [telemetry guide](https://docs.spreecommerce.org/developer/deployment/telemetry)
+for the full span catalog, collector examples, and sampling guidance.
+
+## Code-level configuration
+
+Only needed for what env vars can't express:
+
+```ruby
+# config/initializers/opentelemetry.rb
+SpreeOpenTelemetry.configure do |config|
+  config.use 'OpenTelemetry::Instrumentation::Redis'          # extra instrumentation
+  config.skip 'OpenTelemetry::Instrumentation::ActionMailer'  # drop a default
+  config.with_sdk { |otel| otel.add_span_processor(my_processor) }
+end
+```
+
+## License
+
+Spree is released under the [New BSD License](https://github.com/spree/spree/blob/main/license.md).

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'spree/testing_support/common_rake'
+
+RSpec::Core::RakeTask.new
+
+task default: :spec
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_opentelemetry'
+  Rake::Task['common:test_app'].invoke
+end

data/lib/spree_opentelemetry/configuration.rb

@@ -0,0 +1,61 @@
+module SpreeOpenTelemetry
+  # Code-level configuration, for the few things env vars can't express.
+  # Set from a host initializer:
+  #
+  #   SpreeOpenTelemetry.configure do |config|
+  #     config.service_name = 'storefront-api'
+  #     config.use 'OpenTelemetry::Instrumentation::Redis'
+  #     config.skip 'OpenTelemetry::Instrumentation::ActionMailer'
+  #     config.with_sdk { |otel| otel.add_span_processor(my_processor) }
+  #   end
+  class Configuration
+    DEFAULT_INSTRUMENTATIONS = {
+      'OpenTelemetry::Instrumentation::Rack' => {},
+      'OpenTelemetry::Instrumentation::ActionPack' => {},
+      'OpenTelemetry::Instrumentation::ActionMailer' => {},
+      'OpenTelemetry::Instrumentation::ActiveRecord' => {},
+      'OpenTelemetry::Instrumentation::ActiveSupport' => {},
+      # :link keeps a checkout trace from stretching until the last webhook
+      # retry finishes — background work links to the enqueuing trace instead
+      # of continuing it.
+      'OpenTelemetry::Instrumentation::ActiveJob' => { propagation_style: :link },
+      'OpenTelemetry::Instrumentation::ConcurrentRuby' => {},
+      'OpenTelemetry::Instrumentation::Net::HTTP' => {},
+    }.freeze
+
+    # Force telemetry on/off regardless of exporter env vars; nil (default)
+    # means env-driven activation.
+    attr_accessor :enabled
+
+    # Overrides OTEL_SERVICE_NAME when set.
+    attr_accessor :service_name
+
+    attr_reader :instrumentations, :sdk_hooks
+
+    def initialize
+      @enabled = nil
+      @service_name = nil
+      @instrumentations = DEFAULT_INSTRUMENTATIONS.transform_values(&:dup)
+      @sdk_hooks = []
+    end
+
+    # Adds (or reconfigures) an instrumentation installed at SDK boot.
+    #
+    # @param name [String] instrumentation class name, e.g. 'OpenTelemetry::Instrumentation::Redis'
+    # @param config [Hash] instrumentation-specific options
+    def use(name, config = {})
+      @instrumentations[name.to_s] = config
+    end
+
+    # Removes an instrumentation from the install list.
+    def skip(name)
+      @instrumentations.delete(name.to_s)
+    end
+
+    # Registers a block run inside OpenTelemetry::SDK.configure — the escape
+    # hatch for samplers, extra span processors, resource attributes.
+    def with_sdk(&block)
+      @sdk_hooks << block
+    end
+  end
+end

data/lib/spree_opentelemetry/engine.rb

@@ -0,0 +1,22 @@
+require 'rails/engine'
+
+module SpreeOpenTelemetry
+  class Engine < Rails::Engine
+    engine_name 'spree_opentelemetry'
+
+    # After the host's initializers so a SpreeOpenTelemetry.configure block
+    # is applied before the SDK boots.
+    initializer 'spree_opentelemetry.install', after: :load_config_initializers do
+      SpreeOpenTelemetry.install!
+    end
+
+    # DeliverWebhook is reloadable — its decorator list resets with the class
+    # on every code reload, so registration must happen in to_prepare.
+    config.to_prepare do
+      if SpreeOpenTelemetry.installed? && defined?(Spree::Webhooks::DeliverWebhook)
+        decorators = Spree::Webhooks::DeliverWebhook.header_decorators
+        decorators << SpreeOpenTelemetry::WebhookTracePropagation unless decorators.include?(SpreeOpenTelemetry::WebhookTracePropagation)
+      end
+    end
+  end
+end

data/lib/spree_opentelemetry/span_subscriber.rb

@@ -0,0 +1,89 @@
+module SpreeOpenTelemetry
+  # Turns one ActiveSupport::Notifications event into a span. Evented
+  # (start/finish) rather than block-subscribed, so the span is current while
+  # the instrumented work runs and children nest under it correctly. The span
+  # handle rides in the notification payload — the same trick the upstream
+  # ActiveSupport instrumentation uses.
+  class SpanSubscriber
+    PAYLOAD_KEY = :__spree_opentelemetry_span
+
+    # Workflow control-flow signals inherit Exception by design (a plain
+    # rescue must not swallow them). Halted is a successful early exit and
+    # must not mark the span errored; FailureSignal is a real failure but is
+    # not worth an exception event — the error status carries the verdict.
+    HALT_EXCEPTIONS = %w[Spree::Workflow::Halted].freeze
+    CONTROL_FLOW_EXCEPTIONS = %w[Spree::Workflow::FailureSignal Spree::Workflow::Halted].freeze
+
+    # @param tracer [OpenTelemetry::Trace::Tracer]
+    # @param name [Proc] payload -> span name
+    # @param kind [Proc, nil] payload -> :internal/:client/…; defaults to :internal
+    # @param attributes [Proc, nil] payload -> attribute hash (nil values dropped)
+    # @param skip [Proc, nil] payload -> true suppresses the span entirely
+    # @param error [Proc, nil] payload -> error message when the span failed
+    #   without an exception (e.g. a failure result), nil otherwise
+    def initialize(tracer:, name:, kind: nil, attributes: nil, skip: nil, error: nil)
+      @tracer = tracer
+      @name = name
+      @kind = kind
+      @attributes = attributes
+      @skip = skip
+      @error = error
+    end
+
+    # Instrumentation must never break the instrumented work: a raising
+    # name/kind/attributes proc is reported through the OpenTelemetry error
+    # handler instead of propagating, and finish/detach always run so a bad
+    # proc cannot leak an unfinished span or a stuck context onto the thread.
+    # @param _event_name [String] notification name (unused)
+    # @param _id [String] notification instrumenter id (unused)
+    # @param payload [Hash] notification payload; the span handle is stored on it
+    # @return [void]
+    def start(_event_name, _id, payload)
+      return if @skip&.call(payload)
+
+      span = @tracer.start_span(
+        @name.call(payload),
+        kind: @kind ? @kind.call(payload) : :internal
+      )
+      token = ::OpenTelemetry::Context.attach(::OpenTelemetry::Trace.context_with_span(span))
+      payload[PAYLOAD_KEY] = [span, token]
+    rescue StandardError => error
+      ::OpenTelemetry.handle_error(exception: error, message: "SpreeOpenTelemetry failed to start span #{@name.inspect}")
+      span&.finish if payload[PAYLOAD_KEY].nil?
+    end
+
+    # @param _event_name [String] notification name (unused)
+    # @param _id [String] notification instrumenter id (unused)
+    # @param payload [Hash] notification payload; the span handle is removed from it
+    # @return [void]
+    def finish(_event_name, _id, payload)
+      span, token = payload.delete(PAYLOAD_KEY)
+      return unless span
+
+      begin
+        @attributes&.call(payload)&.each do |key, value|
+          span.set_attribute(key, value) unless value.nil?
+        end
+        record_outcome(span, payload)
+      rescue StandardError => error
+        ::OpenTelemetry.handle_error(exception: error, message: 'SpreeOpenTelemetry failed to finalize span')
+      ensure
+        span.finish
+        ::OpenTelemetry::Context.detach(token)
+      end
+    end
+
+    private
+
+    def record_outcome(span, payload)
+      exception = payload[:exception_object]
+
+      if exception && !HALT_EXCEPTIONS.include?(exception.class.name)
+        span.record_exception(exception) unless CONTROL_FLOW_EXCEPTIONS.include?(exception.class.name)
+        span.status = ::OpenTelemetry::Trace::Status.error(exception.message.to_s)
+      elsif (message = @error&.call(payload))
+        span.status = ::OpenTelemetry::Trace::Status.error(message.to_s)
+      end
+    end
+  end
+end

data/lib/spree_opentelemetry/subscribers.rb

@@ -0,0 +1,145 @@
+require 'active_support/notifications'
+
+module SpreeOpenTelemetry
+  # Attaches one SpanSubscriber per Spree notification family — the
+  # commerce-domain layer on top of the framework auto-instrumentation.
+  # Span names come from bounded vocabularies (workflow keys, step names,
+  # gateway actions, event names); attributes are PII-safe by construction
+  # because the core notification payloads are (see
+  # docs/plans/6.0-opentelemetry.md).
+  module Subscribers
+    class << self
+      # Subscribes one span source per Spree notification family. Idempotent,
+      # so a code reload cannot double-subscribe.
+      #
+      # @return [void]
+      def attach!
+        return if attached?
+
+        tracer = SpreeOpenTelemetry.tracer
+        @subscriptions = definitions(tracer).map do |notification_name, span_subscriber|
+          ActiveSupport::Notifications.subscribe(notification_name, span_subscriber)
+        end
+        @subscriptions << domain_event_subscription
+      end
+
+      # @return [void]
+      def detach!
+        Array(@subscriptions).each { |subscription| ActiveSupport::Notifications.unsubscribe(subscription) }
+        @subscriptions = nil
+      end
+
+      # @return [Boolean] whether the span sources are currently subscribed
+      def attached?
+        !@subscriptions.nil?
+      end
+
+      private
+
+      def definitions(tracer)
+        {
+          'perform.spree_workflow' => SpanSubscriber.new(
+            tracer: tracer,
+            name: ->(payload) { payload[:workflow] },
+            attributes: lambda do |payload|
+              {
+                'spree.workflow' => payload[:workflow],
+                'spree.workflow.outcome' => payload[:outcome]
+              }
+            end,
+            error: ->(payload) { 'workflow failed' if %w[failure error].include?(payload[:outcome]) }
+          ),
+
+          'step.spree_workflow' => SpanSubscriber.new(
+            tracer: tracer,
+            name: ->(payload) { "#{payload[:workflow]} #{payload[:step]}" },
+            kind: ->(payload) { payload[:external] ? :client : :internal },
+            attributes: lambda do |payload|
+              {
+                'spree.workflow' => payload[:workflow],
+                'spree.workflow.step' => payload[:step].to_s,
+                'spree.workflow.step.external' => payload[:external] == true,
+                'spree.workflow.outcome' => payload[:outcome]
+              }
+            end,
+            error: ->(payload) { 'step failed' if payload[:outcome] == 'failure' }
+          ),
+
+          'hooks.spree_workflow' => SpanSubscriber.new(
+            tracer: tracer,
+            name: ->(payload) { "#{payload[:workflow]} hooks #{payload[:hook]}" },
+            skip: ->(payload) { payload[:handler_count].to_i.zero? },
+            attributes: lambda do |payload|
+              {
+                'spree.workflow' => payload[:workflow],
+                'spree.hook' => payload[:hook].to_s,
+                'spree.hook.handler_count' => payload[:handler_count]
+              }
+            end
+          ),
+
+          'dispatch.spree_events' => SpanSubscriber.new(
+            tracer: tracer,
+            name: ->(payload) { "#{payload[:event_name]} dispatch" },
+            attributes: lambda do |payload|
+              {
+                'spree.event.name' => payload[:event_name],
+                'spree.event.subscriber' => payload[:subscriber],
+                'spree.event.async' => payload[:async] == true
+              }
+            end
+          ),
+
+          'deliver.spree_webhooks' => SpanSubscriber.new(
+            tracer: tracer,
+            name: ->(payload) { "spree.webhook.deliver #{payload[:event_name]}" },
+            kind: ->(_payload) { :client },
+            attributes: lambda do |payload|
+              {
+                'spree.webhook.event' => payload[:event_name],
+                'server.address' => payload[:url_host],
+                'http.response.status_code' => payload[:response_code],
+                'spree.webhook.error_type' => payload[:error_type]
+              }
+            end,
+            error: lambda do |payload|
+              next payload[:error_type] if payload[:error_type]
+              next "HTTP #{payload[:response_code]}" if payload[:response_code].to_i >= 400
+
+              nil
+            end
+          ),
+
+          'gateway.spree_payments' => SpanSubscriber.new(
+            tracer: tracer,
+            name: ->(payload) { "spree.gateway.#{payload[:action]}" },
+            kind: ->(_payload) { :client },
+            attributes: lambda do |payload|
+              {
+                'spree.gateway.action' => payload[:action],
+                'spree.gateway.payment_method_type' => payload[:payment_method_type]
+              }
+            end
+          )
+        }
+      end
+
+      # Spree domain events ('order.placed' and friends, published as
+      # '<name>.spree' with an intentionally empty instrumented block) wrap no
+      # work — they surface as span events on the current span, never as
+      # spans. Payloads are deliberately excluded: only the name and event id
+      # are attached.
+      def domain_event_subscription
+        ActiveSupport::Notifications.subscribe(/\.spree$/) do |*args|
+          event = args.last[:event]
+          next unless event
+
+          ::OpenTelemetry::Trace.current_span.add_event(
+            "spree.event #{event.name}",
+            attributes: { 'spree.event.id' => event.id.to_s }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/spree_opentelemetry/webhook_trace_propagation.rb

@@ -0,0 +1,19 @@
+module SpreeOpenTelemetry
+  # DeliverWebhook header decorator — injects W3C trace context
+  # (traceparent/tracestate) into outbound webhook requests so the merchant's
+  # receiving system can join the trace.
+  module WebhookTracePropagation
+    # Trace context only, never the process-global propagator: that one is a
+    # composite that also injects W3C baggage, and baggage carries arbitrary
+    # application context to whatever third-party endpoint the merchant
+    # configured.
+    #
+    # @param headers [Hash] outbound request headers, mutated in place
+    # @param _delivery [Spree::WebhookDelivery] unused; part of the decorator contract
+    # @return [Hash] the same headers hash
+    def self.call(headers, _delivery)
+      ::OpenTelemetry::Trace::Propagation::TraceContext.text_map_propagator.inject(headers)
+      headers
+    end
+  end
+end

data/lib/spree_opentelemetry.rb

@@ -0,0 +1,120 @@
+require 'spree_core'
+
+require 'opentelemetry/sdk'
+require 'opentelemetry-exporter-otlp'
+require 'opentelemetry-instrumentation-rack'
+require 'opentelemetry-instrumentation-action_pack'
+require 'opentelemetry-instrumentation-action_mailer'
+require 'opentelemetry-instrumentation-active_record'
+require 'opentelemetry-instrumentation-active_support'
+require 'opentelemetry-instrumentation-active_job'
+require 'opentelemetry-instrumentation-concurrent_ruby'
+require 'opentelemetry-instrumentation-net_http'
+
+require 'spree_opentelemetry/configuration'
+require 'spree_opentelemetry/span_subscriber'
+require 'spree_opentelemetry/subscribers'
+require 'spree_opentelemetry/webhook_trace_propagation'
+require 'spree_opentelemetry/engine'
+
+# Optional OpenTelemetry support for Spree (docs/plans/6.0-opentelemetry.md).
+#
+# Activation is environment-driven, the way an SRE configures any other
+# OpenTelemetry service: with the gem installed, traces flow as soon as a
+# standard OTEL_* exporter variable is set, and nothing happens without one.
+# `SpreeOpenTelemetry.configure` exists only for code-level needs (extra
+# instrumentations, custom samplers) — telemetry is deployment configuration,
+# never store data.
+module SpreeOpenTelemetry
+  # Env vars whose presence opts this process into exporting traces —
+  # signal-specific endpoint first, matching the SDK's own precedence.
+  EXPORTER_ENV_KEYS = %w[
+    OTEL_EXPORTER_OTLP_TRACES_ENDPOINT
+    OTEL_EXPORTER_OTLP_ENDPOINT
+  ].freeze
+
+  class << self
+    # @return [SpreeOpenTelemetry::Configuration] the process-wide configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # @yieldparam configuration [SpreeOpenTelemetry::Configuration]
+    # @return [SpreeOpenTelemetry::Configuration]
+    def configure
+      yield configuration
+      configuration
+    end
+
+    # Whether telemetry should activate in this process. Dormant unless an
+    # exporter is configured through the standard OpenTelemetry env vars (or
+    # forced on via `configure { |c| c.enabled = true }` — the path
+    # integrations like Sentry's OTLP mode use, since they register their own
+    # exporter); OTEL_SDK_DISABLED is the kill switch and always wins.
+    #
+    # @return [Boolean]
+    def enabled?
+      # OpenTelemetry booleans are case-insensitive, so OTEL_SDK_DISABLED=TRUE
+      # must silence telemetry exactly like the lowercase spelling.
+      return false if ENV['OTEL_SDK_DISABLED'].to_s.casecmp?('true')
+      return configuration.enabled unless configuration.enabled.nil?
+      return true if EXPORTER_ENV_KEYS.any? { |key| !ENV[key].to_s.empty? }
+
+      exporter = ENV['OTEL_TRACES_EXPORTER'].to_s
+      !exporter.empty? && exporter != 'none'
+    end
+
+    # @return [Boolean] whether {#install!} has already run in this process
+    def installed?
+      @installed == true
+    end
+
+    # Boots the OpenTelemetry SDK and attaches the Spree span subscribers.
+    # No-op when {#enabled?} is false — the opentelemetry-api layer stays a
+    # zero-cost no-op in that case. Idempotent.
+    #
+    # @return [Boolean] whether telemetry is installed after the call
+    def install!
+      return true if installed?
+      return false unless enabled?
+
+      ::OpenTelemetry::SDK.configure do |otel_config|
+        otel_config.service_name = configuration.service_name if configuration.service_name
+        configuration.instrumentations.each do |instrumentation_name, instrumentation_config|
+          otel_config.use(instrumentation_name, instrumentation_config)
+        end
+        configuration.sdk_hooks.each { |hook| hook.call(otel_config) }
+      end
+
+      Subscribers.attach!
+      @installed = true
+      log_activation
+      true
+    end
+
+    # @return [OpenTelemetry::Trace::Tracer] the tracer Spree spans are created on
+    def tracer
+      version = defined?(Spree) && Spree.respond_to?(:version) ? Spree.version : nil
+      ::OpenTelemetry.tracer_provider.tracer('spree', version)
+    end
+
+    # Test-only: forget installation state and configuration.
+    #
+    # @return [void]
+    def reset!
+      Subscribers.detach!
+      @installed = nil
+      @configuration = nil
+    end
+
+    private
+
+    def log_activation
+      return unless defined?(Rails) && Rails.logger
+
+      exporter = ENV['OTEL_TRACES_EXPORTER'].to_s.empty? ? 'otlp' : ENV['OTEL_TRACES_EXPORTER']
+      endpoint = EXPORTER_ENV_KEYS.filter_map { |key| ENV[key] unless ENV[key].to_s.empty? }.first || '(default)'
+      Rails.logger.info "[Spree OpenTelemetry] traces active — exporter=#{exporter} endpoint=#{endpoint}"
+    end
+  end
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: spree_opentelemetry
+version: !ruby/object:Gem::Version
+  version: 6.0.0.beta1
+platform: ruby
+authors:
+- Vendo Connect Inc.
+- Vendo Sp. z o.o.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: spree_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 6.0.0.beta1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 6.0.0.beta1
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.26'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.26'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-action_pack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-action_mailer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-active_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-active_job
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-concurrent_ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-net_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Distributed tracing for Spree — boots the OpenTelemetry SDK from standard
+  OTEL_* environment variables and turns Spree workflow, event, webhook and payment-gateway
+  instrumentation into spans
+email: hello@spreecommerce.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/spree_opentelemetry.rb
+- lib/spree_opentelemetry/configuration.rb
+- lib/spree_opentelemetry/engine.rb
+- lib/spree_opentelemetry/span_subscriber.rb
+- lib/spree_opentelemetry/subscribers.rb
+- lib/spree_opentelemetry/webhook_trace_propagation.rb
+homepage: https://spreecommerce.org
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/spree/spree/issues
+  changelog_uri: https://github.com/spree/spree/releases/tag/v6.0.0.beta1
+  documentation_uri: https://docs.spreecommerce.org/
+  source_code_uri: https://github.com/spree/spree/tree/v6.0.0.beta1
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: OpenTelemetry instrumentation for Spree eCommerce platform
+test_files: []