obtrace 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 11e3b6be8a7149d814f0bd72270af0d4ed6b17e0cdfafbb86a4a599ab795385e
+  data.tar.gz: 5a38f50b81015f31611beb14fceb3790eed0af016c9481809470ab8d1c58b97e
+SHA512:
+  metadata.gz: '09cb6ae8a535940b98ba059ef5591ff4b72f67e131f2eef2f0581335db381a877d2d33bf46d2a250d28c7de68af08b5aa000807053af9c553fd2e104a884030b'
+  data.tar.gz: b9cced4a83a66ddf582a39d831b90a6ad8b4f0fcf7f58e6056ccd5be3c4b9bcd11a4180cca68edf1676a61fce655cffa414dc535588569171e729f970a1bbfe1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Obtrace
+
+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,113 @@
+# obtrace-sdk-ruby
+
+Ruby backend SDK for Obtrace telemetry transport and instrumentation.
+
+## Scope
+- OTLP logs/traces/metrics transport
+- Context propagation
+- Rack/Rails middleware baseline
+
+## Design Principle
+SDK is thin/dumb.
+- No business logic authority in client SDK.
+- Policy and product logic are server-side.
+
+## Install
+
+```bash
+# when published as gem
+gem install obtrace-sdk-ruby
+```
+
+Current workspace usage:
+
+```ruby
+require_relative "lib/obtrace_sdk"
+```
+
+## Configuration
+
+Required:
+- `api_key`
+- `ingest_base_url`
+- `service_name`
+
+Optional (auto-resolved from API key on the server side):
+- `tenant_id`
+- `project_id`
+- `app_id`
+- `env`
+- `service_version`
+
+## Quickstart
+
+### Simplified setup
+
+The API key resolves `tenant_id`, `project_id`, `app_id`, and `env` automatically on the server side, so only three fields are needed:
+
+```ruby
+require "obtrace_sdk"
+
+cfg = ObtraceSDK::Config.new(
+  api_key: "obt_live_...",
+  ingest_base_url: "https://ingest.obtrace.io",
+  service_name: "my-service"
+)
+
+client = ObtraceSDK::Client.new(cfg)
+```
+
+### Full configuration
+
+For advanced use cases you can override the resolved values explicitly:
+
+```ruby
+require_relative "lib/obtrace_sdk"
+
+cfg = ObtraceSDK::Config.new(
+  api_key: "<API_KEY>",
+  ingest_base_url: "https://inject.obtrace.ai",
+  service_name: "ruby-api"
+)
+
+client = ObtraceSDK::Client.new(cfg)
+client.log("info", "started")
+client.metric(ObtraceSDK::SemanticMetrics::RUNTIME_CPU_UTILIZATION, 0.41)
+client.span("checkout.charge", attrs: {
+  "feature.name" => "checkout",
+  "payment.provider" => "stripe"
+})
+client.flush
+```
+
+## Canonical metrics and custom spans
+
+- Use `ObtraceSDK::SemanticMetrics::*` for globally normalized metric names.
+- Custom spans use `client.span("name", attrs: {...})`.
+- Keep free-form metric names only for application-specific signals outside the shared catalog.
+
+## Frameworks
+
+- Rack-compatible middleware baseline for Rails usage
+- Reference docs:
+  - `docs/frameworks.md`
+
+## Production Hardening
+
+1. Keep API keys in environment/secret managers.
+2. Separate keys per environment.
+3. Use graceful shutdown hooks to flush queue before exit.
+4. Validate telemetry flow after deploy.
+
+## Troubleshooting
+
+- Missing telemetry: verify endpoint reachability and auth key.
+- Missing correlation: ensure propagation headers are injected.
+- Debug transport with `debug: true` in config.
+
+## Documentation
+- Docs index: `docs/index.md`
+- LLM context file: `llm.txt`
+- MCP metadata: `mcp.json`
+
+## Reference

data/lib/obtrace_sdk/client.rb

@@ -0,0 +1,135 @@
+require "net/http"
+require "json"
+require "uri"
+require_relative "otel_setup"
+
+module ObtraceSDK
+  class Client
+    @@initialized = false
+
+    attr_reader :tracer, :meter, :handshake_ok
+
+    def initialize(cfg)
+      if @@initialized
+        warn("[obtrace-sdk-ruby] already initialized, skipping duplicate init")
+        return
+      end
+
+      raise ArgumentError, "api_key, ingest_base_url and service_name are required" if cfg.api_key.to_s.empty? || cfg.ingest_base_url.to_s.empty? || cfg.service_name.to_s.empty?
+
+      @@initialized = true
+      @cfg = cfg
+      @handshake_ok = false
+      @tracer_provider = OtelSetup.configure(cfg)
+      @tracer = @tracer_provider.tracer("obtrace-sdk-ruby", ObtraceSDK::VERSION)
+      @meter = nil
+      @meter_warning_logged = false
+
+      begin
+        @meter = OpenTelemetry.meter_provider.meter("obtrace-sdk-ruby", ObtraceSDK::VERSION)
+      rescue => _e
+      end
+
+      Thread.new { perform_handshake }
+      at_exit { shutdown }
+    end
+
+    private def perform_handshake
+      base = @cfg.ingest_base_url.to_s.chomp("/")
+      return if base.empty?
+      uri = URI("#{base}/v1/init")
+      payload = JSON.generate({
+        sdk: "obtrace-sdk-ruby",
+        sdk_version: "1.0.0",
+        service_name: @cfg.service_name,
+        service_version: @cfg.service_version.to_s,
+        runtime: "ruby",
+        runtime_version: RUBY_VERSION,
+      })
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = 5
+      http.read_timeout = 5
+      req = Net::HTTP::Post.new(uri)
+      req["Content-Type"] = "application/json"
+      req["Authorization"] = "Bearer #{@cfg.api_key}"
+      req.body = payload
+      resp = http.request(req)
+      if resp.code.to_i == 200
+        @handshake_ok = true
+        warn("[obtrace-sdk-ruby] init handshake OK") if @cfg.debug
+      elsif @cfg.debug
+        warn("[obtrace-sdk-ruby] init handshake failed: #{resp.code}")
+      end
+    rescue => e
+      warn("[obtrace-sdk-ruby] init handshake error: #{e.message}") if @cfg.debug
+    end
+
+    def log(level, message, context = nil)
+      attributes = { "obtrace.log.level" => level.to_s }
+      if context
+        context.each { |k, v| attributes["obtrace.attr.#{k}"] = v.to_s }
+      end
+      attributes["log.severity"] = level.to_s.upcase
+      attributes["log.message"] = message.to_s
+
+      span = OpenTelemetry::Trace.current_span
+      if span && span.context.valid?
+        span.add_event("log", attributes: attributes)
+      else
+        @tracer.in_span("log.#{level}", attributes: attributes) { |_s| }
+      end
+    end
+
+    def metric(name, value, unit = "1", context = nil)
+      warn("[obtrace-sdk-ruby] non-canonical metric name: #{name}") if @cfg.validate_semantic_metrics && @cfg.debug && !SemanticMetrics.semantic_metric?(name)
+
+      unless @meter
+        unless @meter_warning_logged
+          warn("[obtrace-sdk-ruby] meter provider not available, metrics will be dropped")
+          @meter_warning_logged = true
+        end
+        return
+      end
+
+      attrs = {}
+      context&.each { |k, v| attrs[k.to_s] = v.to_s }
+
+      gauge = @meter.create_gauge(name.to_s, unit: unit.to_s)
+      gauge.set(value.to_f, attributes: attrs)
+    end
+
+    def span(name, attrs: nil, &block)
+      span_attrs = {}
+      if attrs
+        attrs.each { |k, v| span_attrs[k.to_s] = v.is_a?(Numeric) || v.is_a?(TrueClass) || v.is_a?(FalseClass) ? v : v.to_s }
+      end
+
+      if block
+        @tracer.in_span(name.to_s, attributes: span_attrs) do |s|
+          block.call(s)
+        end
+      else
+        @tracer.in_span(name.to_s, attributes: span_attrs) { |_s| }
+      end
+    end
+
+    def capture_error(exception, context = nil)
+      exception = Exception.new(exception.to_s) unless exception.is_a?(Exception)
+
+      attrs = {}
+      context&.each { |k, v| attrs[k.to_s] = v.to_s }
+
+      @tracer.in_span("error", attributes: attrs) do |s|
+        s.record_exception(exception)
+        s.status = OpenTelemetry::Trace::Status.error(exception.message.to_s)
+      end
+    end
+
+    alias_method :capture_exception, :capture_error
+
+    def shutdown
+      @tracer_provider.shutdown if @tracer_provider.respond_to?(:shutdown)
+    end
+  end
+end

data/lib/obtrace_sdk/middleware.rb

@@ -0,0 +1,60 @@
+module ObtraceSDK
+  class Middleware
+    def initialize(app, client)
+      @app = app
+      @client = client
+      @tracer = client.tracer
+    end
+
+    def call(env)
+      span_name = "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
+
+      extracted_context = extract_context(env)
+
+      span_attrs = {
+        "http.method" => env["REQUEST_METHOD"].to_s,
+        "http.target" => env["PATH_INFO"].to_s,
+        "http.host" => env["HTTP_HOST"].to_s,
+        "http.scheme" => (env["rack.url_scheme"] || "http").to_s,
+        "http.user_agent" => env["HTTP_USER_AGENT"].to_s,
+        "net.peer.ip" => (env["HTTP_X_FORWARDED_FOR"] || env["REMOTE_ADDR"]).to_s
+      }
+
+      if env["QUERY_STRING"] && !env["QUERY_STRING"].empty?
+        span_attrs["http.query"] = env["QUERY_STRING"]
+      end
+
+      OpenTelemetry::Context.with_current(extracted_context) do
+        @tracer.in_span(span_name, attributes: span_attrs, kind: :server) do |s|
+          begin
+            status, headers, body = @app.call(env)
+            s.set_attribute("http.status_code", status.to_i)
+            if status.to_i >= 500
+              s.status = OpenTelemetry::Trace::Status.error("HTTP #{status}")
+            end
+            [status, headers, body]
+          rescue => e
+            s.record_exception(e)
+            s.status = OpenTelemetry::Trace::Status.error(e.message.to_s)
+            s.set_attribute("http.status_code", 500)
+            raise
+          end
+        end
+      end
+    end
+
+    private
+
+    def extract_context(env)
+      traceparent = env["HTTP_TRACEPARENT"]
+      return OpenTelemetry::Context.current unless traceparent
+
+      OpenTelemetry.propagation.extract(
+        env,
+        getter: OpenTelemetry::Common::Propagation.rack_env_getter
+      )
+    rescue
+      OpenTelemetry::Context.current
+    end
+  end
+end

data/lib/obtrace_sdk/otel_setup.rb

@@ -0,0 +1,71 @@
+require "opentelemetry/sdk"
+require "opentelemetry-exporter-otlp"
+
+module ObtraceSDK
+  module OtelSetup
+    module_function
+
+    def configure(cfg)
+      endpoint = "#{cfg.ingest_base_url.to_s.sub(%r{/$}, "")}/otlp/v1/traces"
+
+      exporter = OpenTelemetry::Exporter::OTLP::Exporter.new(
+        endpoint: endpoint,
+        headers: {
+          "Authorization" => "Bearer #{cfg.api_key}"
+        }.merge(cfg.default_headers || {}),
+        timeout: cfg.request_timeout_sec
+      )
+
+      resource_attrs = {
+        "service.name" => cfg.service_name,
+        "service.version" => cfg.service_version,
+        "deployment.environment" => cfg.env || "dev",
+        "runtime.name" => "ruby"
+      }
+      resource_attrs["obtrace.tenant_id"] = cfg.tenant_id if cfg.tenant_id
+      resource_attrs["obtrace.project_id"] = cfg.project_id if cfg.project_id
+      resource_attrs["obtrace.app_id"] = cfg.app_id if cfg.app_id
+      resource_attrs["obtrace.env"] = cfg.env if cfg.env
+
+      OpenTelemetry::SDK.configure do |c|
+        c.resource = OpenTelemetry::SDK::Resources::Resource.create(resource_attrs)
+        c.add_span_processor(
+          OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(exporter)
+        )
+        auto_detect_instrumentations(c)
+      end
+
+      OpenTelemetry.propagation = OpenTelemetry::Trace::Propagation::TraceContext.text_map_propagator
+
+      OpenTelemetry.tracer_provider
+    end
+
+    def auto_detect_instrumentations(config)
+      instrumentations = [
+        ["OpenTelemetry::Instrumentation::Net::HTTP", "opentelemetry-instrumentation-net_http"],
+        ["OpenTelemetry::Instrumentation::Rack", "opentelemetry-instrumentation-rack"],
+        ["OpenTelemetry::Instrumentation::Rails", "opentelemetry-instrumentation-rails"],
+        ["OpenTelemetry::Instrumentation::PG", "opentelemetry-instrumentation-pg"],
+        ["OpenTelemetry::Instrumentation::Redis", "opentelemetry-instrumentation-redis"],
+        ["OpenTelemetry::Instrumentation::Sidekiq", "opentelemetry-instrumentation-sidekiq"],
+        ["OpenTelemetry::Instrumentation::Faraday", "opentelemetry-instrumentation-faraday"],
+        ["OpenTelemetry::Instrumentation::ActiveRecord", "opentelemetry-instrumentation-active_record"]
+      ]
+
+      threads = instrumentations.map do |class_name, gem_name|
+        Thread.new(class_name, gem_name) do |cn, gn|
+          begin
+            require gn.gsub("-", "/")
+          rescue LoadError
+          end
+        end
+      end
+      threads.each(&:join)
+
+      instrumentations.each do |class_name, gem_name|
+        klass = Object.const_get(class_name) rescue next
+        config.use(class_name) if klass
+      end
+    end
+  end
+end

data/lib/obtrace_sdk/rails.rb

@@ -0,0 +1,37 @@
+require "obtrace_sdk"
+
+module ObtraceSDK
+  class Railtie < ::Rails::Railtie
+    config.after_initialize do |app|
+      api_key = Railtie.credentials_fetch("obtrace_api_key") || ENV["OBTRACE_API_KEY"]
+      ingest_url = Railtie.credentials_fetch("obtrace_ingest_url") || ENV["OBTRACE_INGEST_BASE_URL"] || "https://inject.obtrace.ai"
+      service_name = Railtie.credentials_fetch("obtrace_service_name") || ENV["OBTRACE_SERVICE_NAME"] || ::Rails.application.class.module_parent_name.underscore rescue "rails-app"
+
+      next unless api_key
+
+      cfg = ObtraceSDK::Config.new(
+        api_key: api_key,
+        ingest_base_url: ingest_url,
+        service_name: service_name,
+        env: ::Rails.env.to_s,
+        tenant_id: Railtie.credentials_fetch("obtrace_tenant_id") || ENV["OBTRACE_TENANT_ID"],
+        project_id: Railtie.credentials_fetch("obtrace_project_id") || ENV["OBTRACE_PROJECT_ID"],
+        app_id: Railtie.credentials_fetch("obtrace_app_id") || ENV["OBTRACE_APP_ID"],
+        debug: ENV["OBTRACE_DEBUG"] == "true"
+      )
+
+      client = ObtraceSDK::Client.new(cfg)
+      ObtraceSDK.instance_variable_set(:@rails_client, client)
+
+      app.middleware.insert(0, ObtraceSDK::Middleware, client)
+    end
+
+    def self.Railtie.credentials_fetch(key)
+      ::Rails.application.credentials.send(key) rescue nil
+    end
+  end
+
+  def self.rails_client
+    @rails_client
+  end
+end

data/lib/obtrace_sdk/semantic_metrics.rb

@@ -0,0 +1,55 @@
+module ObtraceSDK
+  module SemanticMetrics
+    THROUGHPUT = "http_requests_total"
+    ERROR_RATE = "http_5xx_total"
+    LATENCY_P95 = "latency_p95"
+    RUNTIME_CPU_UTILIZATION = "runtime.cpu.utilization"
+    RUNTIME_MEMORY_USAGE = "runtime.memory.usage"
+    RUNTIME_THREAD_COUNT = "runtime.thread.count"
+    RUNTIME_GC_PAUSE = "runtime.gc.pause"
+    RUNTIME_EVENTLOOP_LAG = "runtime.eventloop.lag"
+    CLUSTER_CPU_UTILIZATION = "cluster.cpu.utilization"
+    CLUSTER_MEMORY_USAGE = "cluster.memory.usage"
+    CLUSTER_NODE_COUNT = "cluster.node.count"
+    CLUSTER_POD_COUNT = "cluster.pod.count"
+    DB_OPERATION_LATENCY = "db.operation.latency"
+    DB_CLIENT_ERRORS = "db.client.errors"
+    DB_CONNECTIONS_USAGE = "db.connections.usage"
+    MESSAGING_CONSUMER_LAG = "messaging.consumer.lag"
+    WEB_VITAL_LCP = "web.vital.lcp"
+    WEB_VITAL_FCP = "web.vital.fcp"
+    WEB_VITAL_INP = "web.vital.inp"
+    WEB_VITAL_CLS = "web.vital.cls"
+    WEB_VITAL_TTFB = "web.vital.ttfb"
+    USER_ACTIONS = "obtrace.sim.web.react.actions"
+
+    ALL = [
+      THROUGHPUT,
+      ERROR_RATE,
+      LATENCY_P95,
+      RUNTIME_CPU_UTILIZATION,
+      RUNTIME_MEMORY_USAGE,
+      RUNTIME_THREAD_COUNT,
+      RUNTIME_GC_PAUSE,
+      RUNTIME_EVENTLOOP_LAG,
+      CLUSTER_CPU_UTILIZATION,
+      CLUSTER_MEMORY_USAGE,
+      CLUSTER_NODE_COUNT,
+      CLUSTER_POD_COUNT,
+      DB_OPERATION_LATENCY,
+      DB_CLIENT_ERRORS,
+      DB_CONNECTIONS_USAGE,
+      MESSAGING_CONSUMER_LAG,
+      WEB_VITAL_LCP,
+      WEB_VITAL_FCP,
+      WEB_VITAL_INP,
+      WEB_VITAL_CLS,
+      WEB_VITAL_TTFB,
+      USER_ACTIONS
+    ].freeze
+
+    def self.semantic_metric?(name)
+      ALL.include?(name)
+    end
+  end
+end

data/lib/obtrace_sdk/types.rb

@@ -0,0 +1,22 @@
+module ObtraceSDK
+  class Config
+    attr_accessor :api_key, :ingest_base_url, :tenant_id, :project_id, :app_id, :env
+    attr_accessor :service_name, :service_version, :request_timeout_sec
+    attr_accessor :default_headers, :debug, :validate_semantic_metrics
+
+    def initialize(api_key:, ingest_base_url:, service_name:, tenant_id: nil, project_id: nil, app_id: nil, env: "dev", service_version: "1.0.0", request_timeout_sec: 5, default_headers: {}, validate_semantic_metrics: false, debug: false)
+      @api_key = api_key
+      @ingest_base_url = ingest_base_url
+      @tenant_id = tenant_id
+      @project_id = project_id
+      @app_id = app_id
+      @env = env
+      @service_name = service_name
+      @service_version = service_version
+      @request_timeout_sec = request_timeout_sec
+      @default_headers = default_headers
+      @validate_semantic_metrics = validate_semantic_metrics
+      @debug = debug
+    end
+  end
+end

data/lib/obtrace_sdk/version.rb

@@ -0,0 +1,3 @@
+module ObtraceSDK
+  VERSION = "1.0.0"
+end

data/lib/obtrace_sdk.rb

@@ -0,0 +1,6 @@
+require_relative "obtrace_sdk/version"
+require_relative "obtrace_sdk/types"
+require_relative "obtrace_sdk/semantic_metrics"
+require_relative "obtrace_sdk/otel_setup"
+require_relative "obtrace_sdk/client"
+require_relative "obtrace_sdk/middleware"

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: obtrace
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Obtrace
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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-net_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby SDK for Obtrace observability platform. Captures logs, traces, and
+  metrics via OTLP.
+email:
+- dev@obtrace.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/obtrace_sdk.rb
+- lib/obtrace_sdk/client.rb
+- lib/obtrace_sdk/middleware.rb
+- lib/obtrace_sdk/otel_setup.rb
+- lib/obtrace_sdk/rails.rb
+- lib/obtrace_sdk/semantic_metrics.rb
+- lib/obtrace_sdk/types.rb
+- lib/obtrace_sdk/version.rb
+homepage: https://github.com/obtraceai/obtrace-sdk-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/obtraceai/obtrace-sdk-ruby
+  source_code_uri: https://github.com/obtraceai/obtrace-sdk-ruby
+  changelog_uri: https://github.com/obtraceai/obtrace-sdk-ruby/releases
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Obtrace Ruby SDK — observability for Ruby applications
+test_files: []