obtrace-sdk-ruby 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43e85fa41eccf95d2755ea93b8fcbb8f50d878da79328603ac2c12c44b2cf340
-  data.tar.gz: 33804ea6aa4789cc0d6cb78cf24b8edb26b403d6f3ccab469e74cf0a84c9b1fb
+  metadata.gz: c7468e55374f6c051c0def7f03f87796ebab9d4d69ff05132965e66b57bdbadb
+  data.tar.gz: a1d5629df790ebe12837155bb1bf94a9c61edd4ac737450ca4a3a24466dc144f
 SHA512:
-  metadata.gz: 621bc15209d4ffd408bc3ab0a8ddfa4b915bf68061e98e133bfab7fae97682332ce2672903a66ca6ec75fb24aa6c13a1f2a9727ac0948134262fefd972e49c45
-  data.tar.gz: d2d643dc2d854ea490d142a909320fea37b7c7f187a94926764725c457fae35a80241e0b0e8721afea058832c2b998fa08dad81d5c13e920fcaddb94f061b4c2
+  metadata.gz: 77d495287ed0a0f010b57c08e860cec323a138f8a7c23e46051a9bd23abc8b8cc5c4dd6d717c08fefb8aac49d6285d57329846c830bd5a30dcaf3b4cb84bfbbe
+  data.tar.gz: 49fb1d19befa93b2d97485d70d1bf3106e64d340c3e26eb96f7c035e63adfbdff963da1b05787e2b06caedde5f8c7d61ab23fb4282378c29e3766b4ef12b6312

data/lib/obtrace_sdk/client.rb

@@ -1,135 +1,208 @@
-require "net/http"
 require "json"
+require "net/http"
 require "uri"
-require_relative "otel_setup"
+require "thread"
+require_relative "context"
+require_relative "otlp"
+require_relative "http_instrumentation"
+require_relative "logger_capture"
 
 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
+      @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
 
-      begin
-        @meter = OpenTelemetry.meter_provider.meter("obtrace-sdk-ruby", ObtraceSDK::VERSION)
-      rescue => _e
-      end
+    def log(level, message, context = nil)
+      enqueue("/otlp/v1/logs", Otlp.logs_payload(@cfg, level, truncate(message, 32768), context))
+    end
 
-      Thread.new { perform_handshake }
-      at_exit { shutdown }
+    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
 
-    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.1",
-        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}")
+    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
+
+      name = truncate(name, 32768)
+      if attrs
+        attrs = attrs.transform_values { |v| v.is_a?(String) ? truncate(v, 4096) : v }
       end
-    rescue => e
-      warn("[obtrace-sdk-ruby] init handshake error: #{e.message}") if @cfg.debug
+
+      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 }
     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 }
+    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)
+    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
       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| }
+      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
       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
+    def shutdown
+      @tracepoint&.disable
+      flush
+      @lock.synchronize do
+        if @http
+          @http.finish rescue nil
+          @http = nil
+          @http_uri = nil
         end
-        return
       end
+    end
 
-      attrs = {}
-      context&.each { |k, v| attrs[k.to_s] = v.to_s }
+    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"
+          })
+        end
+      end
+      @tracepoint.enable
+    end
 
-      gauge = @meter.create_gauge(name.to_s, unit: unit.to_s)
-      gauge.set(value.to_f, attributes: attrs)
+    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
 
-    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
+    def truncate(s, max)
+      return s if s.length <= max
+      s[0, max] + "...[truncated]"
+    end
 
-      if block
-        @tracer.in_span(name.to_s, attributes: span_attrs) do |s|
-          block.call(s)
+    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
-      else
-        @tracer.in_span(name.to_s, attributes: span_attrs) { |_s| }
+        @queue << { endpoint: endpoint, payload: payload.dup.freeze }
       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)
+    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
+        end
       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
 
-    alias_method :capture_exception, :capture_error
+    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 shutdown
-      @tracer_provider.shutdown if @tracer_provider.respond_to?(:shutdown)
+      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
+      end
     end
   end
 end

data/lib/obtrace_sdk/context.rb

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,122 @@
+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

@@ -0,0 +1,68 @@
+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/middleware.rb

@@ -3,58 +3,84 @@ module ObtraceSDK
     def initialize(app, client)
       @app = app
       @client = client
-      @tracer = client.tracer
     end
 
     def call(env)
-      span_name = "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
+      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)
 
-      extracted_context = extract_context(env)
+      status = nil
+      error = nil
 
-      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
-      }
+      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
 
-      if env["QUERY_STRING"] && !env["QUERY_STRING"].empty?
-        span_attrs["http.query"] = env["QUERY_STRING"]
-      end
+        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
 
-      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
+        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
+        )
+
+        level = if status_code >= 500
+          "error"
+        elsif status_code >= 400
+          "warn"
+        else
+          "info"
+        end
+
+        @client.log(
+          level,
+          "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]} #{status_code} #{duration_ms}ms",
+          attrs
+        )
       end
     end
 
     private
 
-    def extract_context(env)
+    def extract_trace_id(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
+      return nil unless traceparent
+      parts = traceparent.split("-")
+      return nil unless parts.length >= 3
+      parts[1]
     end
   end
 end

data/lib/obtrace_sdk/otlp.rb

@@ -0,0 +1,127 @@
+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

data/lib/obtrace_sdk/rails.rb

@@ -2,10 +2,10 @@ 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"
+    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"
 
       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: 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"],
+        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"],
         debug: ENV["OBTRACE_DEBUG"] == "true"
       )
 
@@ -26,7 +26,7 @@ module ObtraceSDK
       app.middleware.insert(0, ObtraceSDK::Middleware, client)
     end
 
-    def self.Railtie.credentials_fetch(key)
+    def credentials_fetch(key)
       ::Rails.application.credentials.send(key) rescue nil
     end
   end

data/lib/obtrace_sdk/types.rb

@@ -1,10 +1,11 @@
 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 :service_name, :service_version, :max_queue_size, :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", request_timeout_sec: 5, default_headers: {}, validate_semantic_metrics: false, debug: false)
+    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)
       @api_key = api_key
       @ingest_base_url = ingest_base_url
       @tenant_id = tenant_id
@@ -13,10 +14,13 @@ 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.1"
+  VERSION = "1.0.2"
 end

data/lib/obtrace_sdk.rb

@@ -1,6 +1,9 @@
-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/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"

metadata

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

data/lib/obtrace_sdk/otel_setup.rb

@@ -1,71 +0,0 @@
-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