obtrace-sdk-ruby 1.0.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7468e55374f6c051c0def7f03f87796ebab9d4d69ff05132965e66b57bdbadb
-  data.tar.gz: a1d5629df790ebe12837155bb1bf94a9c61edd4ac737450ca4a3a24466dc144f
+  metadata.gz: e0395a5b1787dc1cfc6c7f5385d4c78736580d700efefded562fa2b29d8aeb26
+  data.tar.gz: 7100b663a95f5e2ce98432c649fdeb77057993643fc46ef2cc74ca9820ea5abd
 SHA512:
-  metadata.gz: 77d495287ed0a0f010b57c08e860cec323a138f8a7c23e46051a9bd23abc8b8cc5c4dd6d717c08fefb8aac49d6285d57329846c830bd5a30dcaf3b4cb84bfbbe
-  data.tar.gz: 49fb1d19befa93b2d97485d70d1bf3106e64d340c3e26eb96f7c035e63adfbdff963da1b05787e2b06caedde5f8c7d61ab23fb4282378c29e3766b4ef12b6312
+  metadata.gz: 1f42388bc450d57fa956efed164373acf6d357e652b79d60a5c3f3369ced325575ebf0e05ba51bb1122e8d861612f50b70ad4ba3656d079f46f957e34c38f231
+  data.tar.gz: fd240b922f666c45515dfa963b0c77fe44aacfc144102dcf3e5cc4e560390d9e2e468280ebca82e0bf56a774bd3c86870fd93dfd5ddee5ac70bc2bf4b337e7e2

data/lib/obtrace_sdk/client.rb

@@ -1,208 +1,135 @@
-require "json"
 require "net/http"
+require "json"
 require "uri"
-require "thread"
-require_relative "context"
-require_relative "otlp"
-require_relative "http_instrumentation"
-require_relative "logger_capture"
+require_relative "otel_setup"
 
 module ObtraceSDK
   class Client
-    def initialize(cfg)
-      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 = false
 
-      @cfg = cfg
-      @queue = []
-      @lock = Mutex.new
-      @http = nil
-      @http_uri = nil
-      @circuit_failures = 0
-      @circuit_open_until = Time.at(0)
-      @seen_exceptions = {}
-      @seen_lock = Mutex.new
-
-      install_exception_tracepoint
-      HttpInstrumentation.install(self) if @cfg.auto_instrument_http
-      LoggerCapture.install(self) if @cfg.auto_capture_logs
-      at_exit { capture_fatal; shutdown }
-    end
+    attr_reader :tracer, :meter, :handshake_ok
 
-    def log(level, message, context = nil)
-      enqueue("/otlp/v1/logs", Otlp.logs_payload(@cfg, level, truncate(message, 32768), context))
-    end
+    def initialize(cfg)
+      if @@initialized
+        warn("[obtrace-sdk-ruby] already initialized, skipping duplicate init")
+        return
+      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)
-      enqueue("/otlp/v1/metrics", Otlp.metric_payload(@cfg, truncate(name, 1024), value, unit, context))
-    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?
 
-    def span(name, trace_id: nil, span_id: nil, start_unix_nano: nil, end_unix_nano: nil, status_code: nil, status_message: "", attrs: nil)
-      trace_id ||= Context.random_hex(16)
-      span_id ||= Context.random_hex(8)
-      start_ns = start_unix_nano || Otlp.now_unix_nano
-      end_ns = end_unix_nano || Otlp.now_unix_nano
+      @@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
 
-      name = truncate(name, 32768)
-      if attrs
-        attrs = attrs.transform_values { |v| v.is_a?(String) ? truncate(v, 4096) : v }
+      begin
+        @meter = OpenTelemetry.meter_provider.meter("obtrace-sdk-ruby", ObtraceSDK::VERSION)
+      rescue => _e
       end
 
-      enqueue("/otlp/v1/traces", Otlp.span_payload(@cfg, name, trace_id, span_id, start_ns, end_ns, status_code, status_message, attrs))
-      { trace_id: trace_id, span_id: span_id }
+      Thread.new { perform_handshake }
+      at_exit { shutdown }
     end
 
-    def inject_propagation(headers = {}, trace_id: nil, span_id: nil, session_id: nil)
-      Context.ensure_propagation_headers(headers, trace_id: trace_id, span_id: span_id, session_id: session_id)
+    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.2.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 flush
-      batch = []
-      @lock.synchronize do
-        return if Time.now < @circuit_open_until
-        half_open = @circuit_failures >= 5
-        if half_open
-          return if @queue.empty?
-          batch = [@queue.shift]
-        else
-          batch = @queue.dup
-          @queue.clear
-        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
-      batch.each do |item|
-        success = send_item(item)
-        @lock.synchronize do
-          if success
-            if @circuit_failures > 0
-              warn("[obtrace-sdk-ruby] circuit breaker closed") if @cfg.debug
-              @circuit_failures = 0
-              @circuit_open_until = Time.at(0)
-            end
-          else
-            @circuit_failures += 1
-            if @circuit_failures >= 5
-              @circuit_open_until = Time.now + 30
-              warn("[obtrace-sdk-ruby] circuit breaker opened") if @cfg.debug
-            end
-          end
-        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 shutdown
-      @tracepoint&.disable
-      flush
-      @lock.synchronize do
-        if @http
-          @http.finish rescue nil
-          @http = nil
-          @http_uri = nil
-        end
-      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)
 
-    private
-
-    def install_exception_tracepoint
-      client = self
-      @tracepoint = TracePoint.new(:raise) do |tp|
-        ex = tp.raised_exception
-        eid = ex.object_id
-        seen = client.instance_variable_get(:@seen_lock).synchronize do
-          cache = client.instance_variable_get(:@seen_exceptions)
-          next true if cache[eid]
-          cache[eid] = true
-          cache.shift if cache.size > 200
-          false
-        end
-        unless seen
-          bt = (ex.backtrace || []).first(10).join("\n")
-          client.log("error", "#{ex.class}: #{ex.message}", {
-            "exception.type" => ex.class.to_s,
-            "exception.message" => ex.message.to_s,
-            "exception.stacktrace" => bt,
-            "code.filepath" => tp.path.to_s,
-            "code.lineno" => tp.lineno.to_s,
-            "auto.source" => "tracepoint"
-          })
+      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
-      @tracepoint.enable
-    end
 
-    def capture_fatal
-      return unless $!
-      ex = $!
-      bt = (ex.backtrace || []).first(10).join("\n")
-      log("fatal", "#{ex.class}: #{ex.message}", {
-        "exception.type" => ex.class.to_s,
-        "exception.message" => ex.message.to_s,
-        "exception.stacktrace" => bt,
-        "auto.source" => "at_exit"
-      })
-    end
+      attrs = {}
+      context&.each { |k, v| attrs[k.to_s] = v.to_s }
 
-    def truncate(s, max)
-      return s if s.length <= max
-      s[0, max] + "...[truncated]"
+      gauge = @meter.create_gauge(name.to_s, unit: unit.to_s)
+      gauge.set(value.to_f, attributes: attrs)
     end
 
-    def enqueue(endpoint, payload)
-      @lock.synchronize do
-        if @queue.length >= @cfg.max_queue_size
-          @queue.shift
-          warn("[obtrace-sdk-ruby] queue full, dropping oldest item") if @cfg.debug
-        end
-        @queue << { endpoint: endpoint, payload: payload.dup.freeze }
+    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
-    end
 
-    def connection_for(uri)
-      if @http && @http_uri && @http_uri.host == uri.host && @http_uri.port == uri.port
-        begin
-          return @http if @http.started?
-        rescue StandardError
+      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
-
-      @http.finish rescue nil if @http
-      @http = Net::HTTP.new(uri.host, uri.port)
-      @http.use_ssl = uri.scheme == "https"
-      @http.read_timeout = @cfg.request_timeout_sec
-      @http.start
-      @http_uri = uri
-      @http
     end
 
-    def send_item(item)
-      uri = URI.parse("#{@cfg.ingest_base_url.to_s.sub(%r{/$}, "")}#{item[:endpoint]}")
-      http = connection_for(uri)
-      req = Net::HTTP::Post.new(uri.request_uri)
-      req["Authorization"] = "Bearer #{@cfg.api_key}"
-      req["Content-Type"] = "application/json"
-      (@cfg.default_headers || {}).each { |k, v| req[k] = v.to_s }
-      req.body = JSON.generate(item[:payload])
+    def capture_error(exception, context = nil)
+      exception = Exception.new(exception.to_s) unless exception.is_a?(Exception)
 
-      retries = 0
-      begin
-        res = http.request(req)
-        if res.code.to_i >= 300
-          warn("[obtrace-sdk-ruby] status=#{res.code} endpoint=#{item[:endpoint]} body=#{res.body}") if @cfg.debug
-          return false
-        end
-        true
-      rescue StandardError => e
-        if retries < 2
-          retries += 1
-          sleep 1
-          @http.finish rescue nil
-          @http = nil
-          http = connection_for(uri)
-          retry
-        end
-        warn("[obtrace-sdk-ruby] send failed endpoint=#{item[:endpoint]} err=#{e.message}") if @cfg.debug
-        false
+      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

@@ -3,84 +3,58 @@ module ObtraceSDK
     def initialize(app, client)
       @app = app
       @client = client
+      @tracer = client.tracer
     end
 
     def call(env)
-      trace_id = extract_trace_id(env) || Context.random_hex(16)
-      span_id = Context.random_hex(8)
-      start_ns = Otlp.now_unix_nano
-      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      span_name = "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
 
-      status = nil
-      error = nil
+      extracted_context = extract_context(env)
 
-      begin
-        status, headers, body = @app.call(env)
-        [status, headers, body]
-      rescue => e
-        error = e
-        raise
-      ensure
-        end_ns = Otlp.now_unix_nano
-        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
-        status_code = error ? 500 : status.to_i
+      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
+      }
 
-        attrs = {
-          "http.method" => env["REQUEST_METHOD"],
-          "http.target" => env["PATH_INFO"],
-          "http.host" => env["HTTP_HOST"].to_s,
-          "http.scheme" => env["rack.url_scheme"].to_s,
-          "http.status_code" => status_code,
-          "http.duration_ms" => duration_ms,
-          "http.user_agent" => env["HTTP_USER_AGENT"].to_s,
-          "net.peer.ip" => (env["HTTP_X_FORWARDED_FOR"] || env["REMOTE_ADDR"]).to_s
-        }
-
-        if error
-          attrs["error"] = true
-          attrs["error.type"] = error.class.to_s
-          attrs["error.message"] = error.message.to_s
-        end
-
-        if env["QUERY_STRING"] && !env["QUERY_STRING"].empty?
-          attrs["http.query"] = env["QUERY_STRING"]
-        end
-
-        @client.span(
-          "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}",
-          trace_id: trace_id,
-          span_id: span_id,
-          start_unix_nano: start_ns,
-          end_unix_nano: end_ns,
-          status_code: status_code >= 400 ? status_code : nil,
-          status_message: error ? error.message : "",
-          attrs: attrs
-        )
+      if env["QUERY_STRING"] && !env["QUERY_STRING"].empty?
+        span_attrs["http.query"] = env["QUERY_STRING"]
+      end
 
-        level = if status_code >= 500
-          "error"
-        elsif status_code >= 400
-          "warn"
-        else
-          "info"
+      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
-
-        @client.log(
-          level,
-          "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]} #{status_code} #{duration_ms}ms",
-          attrs
-        )
       end
     end
 
     private
 
-    def extract_trace_id(env)
+    def extract_context(env)
       traceparent = env["HTTP_TRACEPARENT"]
-      return nil unless traceparent
-      parts = traceparent.split("-")
-      return nil unless parts.length >= 3
-      parts[1]
+      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

@@ -2,10 +2,10 @@ require "obtrace_sdk"
 
 module ObtraceSDK
   class Railtie < ::Rails::Railtie
-    initializer "obtrace_sdk.configure" do |app|
-      api_key = credentials_fetch("obtrace_api_key") || ENV["OBTRACE_API_KEY"]
-      ingest_url = credentials_fetch("obtrace_ingest_url") || ENV["OBTRACE_INGEST_BASE_URL"] || "https://inject.obtrace.ai"
-      service_name = credentials_fetch("obtrace_service_name") || ENV["OBTRACE_SERVICE_NAME"] || ::Rails.application.class.module_parent_name.underscore rescue "rails-app"
+    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
 
@@ -14,9 +14,9 @@ module ObtraceSDK
         ingest_base_url: ingest_url,
         service_name: service_name,
         env: ::Rails.env.to_s,
-        tenant_id: credentials_fetch("obtrace_tenant_id") || ENV["OBTRACE_TENANT_ID"],
-        project_id: credentials_fetch("obtrace_project_id") || ENV["OBTRACE_PROJECT_ID"],
-        app_id: credentials_fetch("obtrace_app_id") || ENV["OBTRACE_APP_ID"],
+        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"
       )
 
@@ -26,7 +26,7 @@ module ObtraceSDK
       app.middleware.insert(0, ObtraceSDK::Middleware, client)
     end
 
-    def credentials_fetch(key)
+    def self.Railtie.credentials_fetch(key)
       ::Rails.application.credentials.send(key) rescue nil
     end
   end

data/lib/obtrace_sdk/types.rb

@@ -1,11 +1,10 @@
 module ObtraceSDK
   class Config
     attr_accessor :api_key, :ingest_base_url, :tenant_id, :project_id, :app_id, :env
-    attr_accessor :service_name, :service_version, :max_queue_size, :request_timeout_sec
+    attr_accessor :service_name, :service_version, :request_timeout_sec
     attr_accessor :default_headers, :debug, :validate_semantic_metrics
-    attr_accessor :auto_instrument_http, :auto_capture_logs
 
-    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", max_queue_size: 1000, request_timeout_sec: 5, default_headers: {}, validate_semantic_metrics: false, debug: false, auto_instrument_http: true, auto_capture_logs: true)
+    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
@@ -14,13 +13,10 @@ module ObtraceSDK
       @env = env
       @service_name = service_name
       @service_version = service_version
-      @max_queue_size = max_queue_size
       @request_timeout_sec = request_timeout_sec
       @default_headers = default_headers
       @validate_semantic_metrics = validate_semantic_metrics
       @debug = debug
-      @auto_instrument_http = auto_instrument_http
-      @auto_capture_logs = auto_capture_logs
     end
   end
 end

data/lib/obtrace_sdk/version.rb

@@ -1,3 +1,3 @@
 module ObtraceSDK
-  VERSION = "1.0.2"
+  VERSION = "1.2.0"
 end

data/lib/obtrace_sdk.rb

@@ -1,9 +1,6 @@
+require_relative "obtrace_sdk/version"
 require_relative "obtrace_sdk/types"
-require_relative "obtrace_sdk/context"
-require_relative "obtrace_sdk/otlp"
-require_relative "obtrace_sdk/http_instrumentation"
-require_relative "obtrace_sdk/logger_capture"
-require_relative "obtrace_sdk/middleware"
-require_relative "obtrace_sdk/client"
-require_relative "obtrace_sdk/framework"
 require_relative "obtrace_sdk/semantic_metrics"
+require_relative "obtrace_sdk/otel_setup"
+require_relative "obtrace_sdk/client"
+require_relative "obtrace_sdk/middleware"

metadata

@@ -1,23 +1,65 @@
 --- !ruby/object:Gem::Specification
 name: obtrace-sdk-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Obtrace
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-28 00:00:00.000000000 Z
+date: 2026-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: net-http
+  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: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -25,13 +67,27 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: json
+  name: opentelemetry-instrumentation-rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  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:
@@ -50,12 +106,8 @@ files:
 - README.md
 - lib/obtrace_sdk.rb
 - lib/obtrace_sdk/client.rb
-- lib/obtrace_sdk/context.rb
-- lib/obtrace_sdk/framework.rb
-- lib/obtrace_sdk/http_instrumentation.rb
-- lib/obtrace_sdk/logger_capture.rb
 - lib/obtrace_sdk/middleware.rb
-- lib/obtrace_sdk/otlp.rb
+- lib/obtrace_sdk/otel_setup.rb
 - lib/obtrace_sdk/rails.rb
 - lib/obtrace_sdk/semantic_metrics.rb
 - lib/obtrace_sdk/types.rb

data/lib/obtrace_sdk/context.rb

@@ -1,18 +0,0 @@
-require "securerandom"
-
-module ObtraceSDK
-  module Context
-    module_function
-
-    def random_hex(bytes)
-      SecureRandom.hex(bytes)
-    end
-
-    def ensure_propagation_headers(headers = {}, trace_id: nil, span_id: nil, session_id: nil)
-      out = (headers || {}).dup
-      out["traceparent"] ||= "00-#{trace_id || random_hex(16)}-#{span_id || random_hex(8)}-01"
-      out["x-obtrace-session-id"] ||= session_id if session_id && !session_id.empty?
-      out
-    end
-  end
-end

data/lib/obtrace_sdk/framework.rb

@@ -1,15 +0,0 @@
-module ObtraceSDK
-  module Framework
-    module_function
-
-    # Rack-compatible middleware baseline used by Rails.
-    def rack_middleware(client, app)
-      lambda do |env|
-        client.log("info", "request.start", { method: env["REQUEST_METHOD"], path: env["PATH_INFO"] })
-        status, headers, body = app.call(env)
-        client.log("info", "request.finish", { status: status.to_i })
-        [status, headers, body]
-      end
-    end
-  end
-end

data/lib/obtrace_sdk/http_instrumentation.rb

@@ -1,122 +0,0 @@
-require "net/http"
-
-module ObtraceSDK
-  module HttpInstrumentation
-    @client = nil
-    @installed = false
-
-    module_function
-
-    def install(client)
-      return if @installed
-      @client = client
-      @installed = true
-
-      Net::HTTP.prepend(NetHttpPatch)
-    end
-
-    def client
-      @client
-    end
-
-    def installed?
-      @installed
-    end
-
-    def reset!
-      @client = nil
-      @installed = false
-    end
-
-    module NetHttpPatch
-      def request(req, body = nil, &block)
-        client = ObtraceSDK::HttpInstrumentation.client
-        unless client
-          return super
-        end
-
-        uri = URI.parse("#{use_ssl? ? 'https' : 'http'}://#{address}:#{port}#{req.path}")
-
-        if uri.host && ObtraceSDK::HttpInstrumentation.own_endpoint?(uri)
-          return super
-        end
-
-        trace_id = ObtraceSDK::Context.random_hex(16)
-        span_id = ObtraceSDK::Context.random_hex(8)
-
-        req["traceparent"] ||= "00-#{trace_id}-#{span_id}-01"
-
-        start_ns = ObtraceSDK::Otlp.now_unix_nano
-        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        status_code = nil
-        error = nil
-
-        begin
-          response = super
-          status_code = response.code.to_i
-          response
-        rescue => e
-          error = e
-          raise
-        ensure
-          end_ns = ObtraceSDK::Otlp.now_unix_nano
-          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
-
-          attrs = {
-            "http.method" => req.method,
-            "http.url" => uri.to_s,
-            "http.host" => uri.host.to_s,
-            "net.peer.port" => uri.port.to_s,
-            "http.duration_ms" => duration_ms,
-            "auto.source" => "http_instrumentation"
-          }
-
-          if status_code
-            attrs["http.status_code"] = status_code
-          end
-
-          if error
-            attrs["error"] = true
-            attrs["error.type"] = error.class.to_s
-            attrs["error.message"] = error.message.to_s
-          end
-
-          span_status = if error
-            status_code = 500
-            500
-          elsif status_code && status_code >= 400
-            status_code
-          else
-            nil
-          end
-
-          client.span(
-            "HTTP #{req.method}",
-            trace_id: trace_id,
-            span_id: span_id,
-            start_unix_nano: start_ns,
-            end_unix_nano: end_ns,
-            status_code: span_status,
-            status_message: error ? error.message : "",
-            attrs: attrs
-          )
-
-          client.log(
-            status_code && status_code >= 400 ? "warn" : "info",
-            "HTTP #{req.method} #{uri.host}#{uri.path} #{status_code || 'ERR'}",
-            attrs
-          )
-        end
-      end
-    end
-
-    def self.own_endpoint?(uri)
-      return false unless @client
-      cfg = @client.instance_variable_get(:@cfg)
-      return false unless cfg
-      ingest_uri = URI.parse(cfg.ingest_base_url.to_s) rescue nil
-      return false unless ingest_uri
-      uri.host == ingest_uri.host && uri.port == ingest_uri.port
-    end
-  end
-end

data/lib/obtrace_sdk/logger_capture.rb

@@ -1,68 +0,0 @@
-require "logger"
-
-module ObtraceSDK
-  module LoggerCapture
-    @client = nil
-    @installed = false
-
-    SEVERITY_MAP = {
-      0 => "debug",
-      1 => "info",
-      2 => "warn",
-      3 => "error",
-      4 => "fatal",
-      5 => "unknown"
-    }.freeze
-
-    module_function
-
-    def install(client)
-      return if @installed
-      @client = client
-      @installed = true
-
-      ::Logger.prepend(LoggerPatch)
-    end
-
-    def client
-      @client
-    end
-
-    def installed?
-      @installed
-    end
-
-    def reset!
-      @client = nil
-      @installed = false
-    end
-
-    module LoggerPatch
-      def add(severity, message = nil, progname = nil, &block)
-        result = super
-
-        client = ObtraceSDK::LoggerCapture.client
-        if client
-          if message.nil?
-            if block
-              msg = block.call
-            else
-              msg = progname
-            end
-          else
-            msg = message
-          end
-
-          if msg && !msg.to_s.empty?
-            level = ObtraceSDK::LoggerCapture::SEVERITY_MAP[severity] || "unknown"
-            attrs = { "auto.source" => "logger_capture" }
-            attrs["logger.progname"] = progname.to_s if progname && message
-            client.log(level, msg.to_s, attrs)
-          end
-        end
-
-        result
-      end
-    end
-  end
-end

data/lib/obtrace_sdk/otlp.rb

@@ -1,127 +0,0 @@
-module ObtraceSDK
-  module Otlp
-    module_function
-
-    def attrs(hash)
-      return [] if hash.nil?
-      hash.map do |k, v|
-        value =
-          case v
-          when TrueClass, FalseClass
-            { "boolValue" => v }
-          when Numeric
-            { "doubleValue" => v.to_f }
-          else
-            { "stringValue" => v.to_s }
-          end
-        { "key" => k.to_s, "value" => value }
-      end
-    end
-
-    def resource(cfg)
-      base = {
-        "service.name" => cfg.service_name,
-        "service.version" => cfg.service_version,
-        "deployment.environment" => cfg.env || "dev",
-        "runtime.name" => "ruby"
-      }
-      base["obtrace.tenant_id"] = cfg.tenant_id if cfg.tenant_id
-      base["obtrace.project_id"] = cfg.project_id if cfg.project_id
-      base["obtrace.app_id"] = cfg.app_id if cfg.app_id
-      base["obtrace.env"] = cfg.env if cfg.env
-      attrs(base)
-    end
-
-    def now_unix_nano
-      (Time.now.to_f * 1_000_000_000).to_i.to_s
-    end
-
-    def logs_payload(cfg, level, message, context = nil)
-      context_attrs = { "obtrace.log.level" => level }
-      if context
-        context.each { |k, v| context_attrs["obtrace.attr.#{k}"] = v }
-      end
-
-      {
-        "resourceLogs" => [
-          {
-            "resource" => { "attributes" => resource(cfg) },
-            "scopeLogs" => [
-              {
-                "scope" => { "name" => "obtrace-sdk-ruby", "version" => "1.0.0" },
-                "logRecords" => [
-                  {
-                    "timeUnixNano" => now_unix_nano,
-                    "severityText" => level.to_s.upcase,
-                    "body" => { "stringValue" => message.to_s },
-                    "attributes" => attrs(context_attrs)
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    end
-
-    def metric_payload(cfg, name, value, unit = "1", context = nil)
-      {
-        "resourceMetrics" => [
-          {
-            "resource" => { "attributes" => resource(cfg) },
-            "scopeMetrics" => [
-              {
-                "scope" => { "name" => "obtrace-sdk-ruby", "version" => "1.0.0" },
-                "metrics" => [
-                  {
-                    "name" => name.to_s,
-                    "unit" => unit.to_s,
-                    "gauge" => {
-                      "dataPoints" => [
-                        {
-                          "timeUnixNano" => now_unix_nano,
-                          "asDouble" => value.to_f,
-                          "attributes" => attrs(context || {})
-                        }
-                      ]
-                    }
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    end
-
-    def span_payload(cfg, name, trace_id, span_id, start_unix_nano, end_unix_nano, status_code = nil, status_message = "", attrs_hash = nil)
-      {
-        "resourceSpans" => [
-          {
-            "resource" => { "attributes" => resource(cfg) },
-            "scopeSpans" => [
-              {
-                "scope" => { "name" => "obtrace-sdk-ruby", "version" => "1.0.0" },
-                "spans" => [
-                  {
-                    "traceId" => trace_id,
-                    "spanId" => span_id,
-                    "name" => name.to_s,
-                    "kind" => 3,
-                    "startTimeUnixNano" => start_unix_nano,
-                    "endTimeUnixNano" => end_unix_nano,
-                    "attributes" => attrs(attrs_hash || {}),
-                    "status" => {
-                      "code" => status_code && status_code.to_i >= 400 ? 2 : 1,
-                      "message" => status_message.to_s
-                    }
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    end
-  end
-end