flare 0.3.0 → 0.4.0

data/lib/flare/sqlite_exporter.rb

@@ -3,6 +3,8 @@
 require "sqlite3"
 require "json"
 
+require_relative "deadline"
+
 module Flare
   class SQLiteExporter
     SUCCESS = OpenTelemetry::SDK::Trace::Export::SUCCESS
@@ -16,45 +18,61 @@ module Flare
       @database_path = database_path
       @mutex = Mutex.new
       @setup = false
+      @pid = $$
     end
 
     # Maximum number of retry attempts when the database is busy.
     # Mirrors ActiveRecord's retry strategy for SQLite.
     MAX_RETRIES = 3
+    ExportDeadlineExceeded = Class.new(StandardError)
 
     def export(span_datas, timeout: nil)
-      setup_database unless @setup
+      detect_forking
+      deadline = Deadline.new(timeout)
 
       retries = 0
       exported = 0
 
       begin
-        @mutex.synchronize do
+        setup_database(deadline) unless @setup
+        raise ExportDeadlineExceeded if deadline.expired?
+        raise ExportDeadlineExceeded unless lock_before_deadline(deadline)
+
+        begin
+          apply_busy_timeout(deadline)
           connection.transaction do
             span_datas.each do |span_data|
+              raise ExportDeadlineExceeded if deadline.expired?
               next if should_ignore_span?(span_data)
 
               create_span(span_data)
               exported += 1
             end
           end
+        ensure
+          @mutex.unlock
         end
+      rescue ExportDeadlineExceeded
+        return TIMEOUT
       rescue ::SQLite3::BusyException
         retries += 1
         if retries <= MAX_RETRIES
-          sleep 0.1 * retries
+          sleep_time = 0.1 * retries
+          return TIMEOUT if deadline.remaining && sleep_time >= deadline.remaining
+
+          sleep(sleep_time)
           retry
         end
         warn "[Flare] SQLite export error: database is busy after #{MAX_RETRIES} retries"
         return FAILURE
       end
 
-      Flare.log "Exported #{exported} spans to SQLite" if exported > 0
+      Flare.log "Exported #{exported} spans to SQLite" if exported > 0 && Flare.respond_to?(:log)
 
       # Periodically prune old data
-      maybe_prune
+      maybe_prune unless deadline.expired?
 
-      SUCCESS
+      deadline.expired? ? TIMEOUT : SUCCESS
     rescue => e
       warn "[Flare] SQLite export error: #{e.message}"
       FAILURE
@@ -70,6 +88,31 @@ module Flare
 
     private
 
+    def detect_forking
+      return if @pid == $$
+
+      @pid = $$
+      @mutex = Mutex.new
+      close_connection
+    end
+
+    def lock_before_deadline(deadline)
+      return @mutex.lock unless deadline.remaining
+
+      until @mutex.try_lock
+        return false if deadline.expired?
+
+        sleep([deadline.remaining, 0.001].min)
+      end
+      true
+    end
+
+    def apply_busy_timeout(deadline)
+      remaining = deadline.remaining
+      timeout_ms = remaining ? [(remaining * 1_000).floor, 1].max : 5_000
+      connection.busy_timeout = [timeout_ms, 5_000].min
+    end
+
     def maybe_prune
       return unless rand < PRUNE_PROBABILITY
 
@@ -162,14 +205,16 @@ module Flare
       end
     end
 
-    def setup_database
-      @mutex.synchronize do
+    def setup_database(deadline)
+      raise ExportDeadlineExceeded unless lock_before_deadline(deadline)
+
+      begin
         return if @setup
 
         db = connection
-        configure_pragmas(db)
+        configure_pragmas(db, deadline)
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE TABLE IF NOT EXISTS flare_spans (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             name TEXT NOT NULL,
@@ -187,23 +232,23 @@ module Flare
           )
         SQL
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE INDEX IF NOT EXISTS idx_spans_span_id ON flare_spans(span_id)
         SQL
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE INDEX IF NOT EXISTS idx_spans_trace_id ON flare_spans(trace_id)
         SQL
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE INDEX IF NOT EXISTS idx_spans_parent_span_id ON flare_spans(parent_span_id)
         SQL
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE INDEX IF NOT EXISTS idx_spans_created_at ON flare_spans(created_at)
         SQL
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE TABLE IF NOT EXISTS flare_events (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             span_id INTEGER NOT NULL,
@@ -214,11 +259,11 @@ module Flare
           )
         SQL
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE INDEX IF NOT EXISTS idx_events_span_id ON flare_events(span_id)
         SQL
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE TABLE IF NOT EXISTS flare_properties (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             key TEXT NOT NULL,
@@ -231,27 +276,37 @@ module Flare
           )
         SQL
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE INDEX IF NOT EXISTS idx_properties_owner ON flare_properties(owner_type, owner_id)
         SQL
 
-        db.execute(<<~SQL)
+        execute_setup(db, deadline, <<~SQL)
           CREATE INDEX IF NOT EXISTS idx_properties_key ON flare_properties(key)
         SQL
 
         close_connection # avoid inheriting connection across fork
         @setup = true
+      ensure
+        @mutex.unlock
       end
     end
 
     # Applies the same SQLite pragmas that ActiveRecord uses for good
     # concurrency and performance with threaded/multi-process access.
-    def configure_pragmas(db)
-      db.execute("PRAGMA journal_mode=WAL")
-      db.execute("PRAGMA synchronous=NORMAL")
-      db.execute("PRAGMA mmap_size=134217728")        # 128MB
-      db.execute("PRAGMA journal_size_limit=67108864") # 64MB
-      db.execute("PRAGMA cache_size=2000")
+    def configure_pragmas(db, deadline)
+      execute_setup(db, deadline, "PRAGMA journal_mode=WAL")
+      execute_setup(db, deadline, "PRAGMA synchronous=NORMAL")
+      execute_setup(db, deadline, "PRAGMA mmap_size=134217728")         # 128MB
+      execute_setup(db, deadline, "PRAGMA journal_size_limit=67108864") # 64MB
+      execute_setup(db, deadline, "PRAGMA cache_size=2000")
+    end
+
+    def execute_setup(db, deadline, statement)
+      raise ExportDeadlineExceeded if deadline.expired?
+
+      apply_busy_timeout(deadline)
+      db.execute(statement)
+      raise ExportDeadlineExceeded if deadline.expired?
     end
 
     def connection_key

data/lib/flare/trace_exporter.rb

@@ -8,9 +8,11 @@ require "uri"
 require "concurrent/atomic/atomic_fixnum"
 require "opentelemetry/sdk"
 
+require_relative "client_headers"
 require_relative "sampler"
 require_relative "trace_blob"
 require_relative "http_transport"
+require_relative "deadline"
 
 module Flare
   # Custom OTel exporter. For each batch FilteringSpanProcessor hands over:
@@ -32,6 +34,7 @@ module Flare
   class TraceExporter
     SUCCESS = OpenTelemetry::SDK::Trace::Export::SUCCESS
     FAILURE = OpenTelemetry::SDK::Trace::Export::FAILURE
+    TIMEOUT = OpenTelemetry::SDK::Trace::Export::TIMEOUT
 
     PUT_HEADERS = {
       "Content-Type"     => "application/json",
@@ -57,16 +60,22 @@ module Flare
     end
 
     def export(spans, timeout: nil)
+      deadline = Deadline.new(timeout)
       grouped = spans.group_by(&:trace_id)
       return SUCCESS if grouped.empty?
 
       overall = SUCCESS
       grouped.each do |trace_id, group|
-        result = ship(TraceBlob.build(trace_id: trace_id, spans: group))
+        return TIMEOUT if deadline.expired?
+
+        result = ship(TraceBlob.build(trace_id: trace_id, spans: group), deadline: deadline)
+        return TIMEOUT if result == TIMEOUT || deadline.expired?
         overall = FAILURE if result == FAILURE
       end
       overall
     rescue StandardError => e
+      return TIMEOUT if deadline&.expired? || e.is_a?(HttpTransport::DeadlineExceeded)
+
       @exception_count.increment
       @logger.warn("[Flare::TraceExporter] export raised: #{e.class}: #{e.message}")
       FAILURE
@@ -82,8 +91,9 @@ module Flare
 
     private
 
-    def ship(blob, retried: false)
+    def ship(blob, deadline:, retried: false)
       return FAILURE if blob.nil?
+      return TIMEOUT if deadline.expired?
 
       entry = @pool.checkout
       if entry.nil?
@@ -92,38 +102,67 @@ module Flare
       end
 
       body = gzip(JSON.generate(blob.to_h))
-      response = @transport.put(entry[:put_url], body, PUT_HEADERS)
+      response = transport_request(:put, entry[:put_url], body, PUT_HEADERS, timeout: deadline.remaining)
+      return TIMEOUT if deadline.expired?
 
       case response.code
       when "200", "204"
-        notify(entry[:key])
-        SUCCESS
+        notify(entry[:key], deadline: deadline)
       when "403"
         # Presigned URL probably expired; try once more with the next one.
-        retried ? record_put_failure(response) : ship(blob, retried: true)
+        retried ? record_put_failure(response) : ship(blob, deadline: deadline, retried: true)
       else
         record_put_failure(response)
       end
     end
 
-    def notify(key)
-      response = @transport.post(@notify_url, JSON.generate(key: key), notify_headers)
-      return if response.code == "202"
+    def notify(key, deadline:)
+      return TIMEOUT if deadline.expired?
+
+      response = transport_request(
+        :post,
+        @notify_url,
+        JSON.generate(key: key),
+        notify_headers,
+        timeout: deadline.remaining
+      )
+      return TIMEOUT if deadline.expired?
+      return SUCCESS if response.code == "202"
 
       @notify_failure_count.increment
       @logger.warn("[Flare::TraceExporter] notify failed: HTTP #{response.code}")
+      SUCCESS
     rescue StandardError => e
+      return TIMEOUT if deadline.expired? || e.is_a?(HttpTransport::DeadlineExceeded)
+
       @notify_failure_count.increment
       @logger.warn("[Flare::TraceExporter] notify exception: #{e.class}: #{e.message}")
+      SUCCESS
+    end
+
+    def transport_request(method, *args, timeout:)
+      parameters = @transport.method(method).parameters
+      accepts_timeout = parameters.any? do |type, name|
+        type == :keyrest || ([:key, :keyreq].include?(type) && name == :timeout)
+      end
+
+      if accepts_timeout
+        @transport.public_send(method, *args, timeout: timeout)
+      else
+        @transport.public_send(method, *args)
+      end
     end
 
+    # Identifies the client on the Flare-API notify POST. The presigned R2
+    # PUT in #ship deliberately uses PUT_HEADERS only -- adding these there
+    # could invalidate the signed-header set.
     def notify_headers
-      {
+      ClientHeaders.to_h.merge(
         "Content-Type"      => "application/json",
         "Authorization"     => "Bearer #{@api_key}",
         "Flare-Project"     => @project,
         "Flare-Environment" => @environment
-      }
+      )
     end
 
     def record_put_failure(response)

data/lib/flare/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flare
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/flare.rb

@@ -5,6 +5,7 @@ require_relative "flare/configuration"
 
 require "opentelemetry/sdk"
 
+require_relative "flare/client_headers"
 require_relative "flare/source_location"
 require_relative "flare/metric_key"
 require_relative "flare/metric_storage"
@@ -12,6 +13,8 @@ require_relative "flare/metric_span_processor"
 require_relative "flare/metric_flusher"
 require_relative "flare/backoff_policy"
 require_relative "flare/metric_submitter"
+require_relative "flare/recording_batch_span_processor"
+require_relative "flare/lifecycle"
 
 require_relative "flare/sampler"
 require_relative "flare/marker"
@@ -87,7 +90,7 @@ module Flare
   end
 
   def span_processor
-    @span_processor ||= OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+    @span_processor ||= RecordingBatchSpanProcessor.new(
       exporter,
       max_queue_size: 1000,
       max_export_batch_size: 100,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flare
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - John Nunemaker
@@ -196,11 +196,14 @@ files:
 - lib/flare/cli/output.rb
 - lib/flare/cli/setup_command.rb
 - lib/flare/cli/status_command.rb
+- lib/flare/client_headers.rb
 - lib/flare/configuration.rb
+- lib/flare/deadline.rb
 - lib/flare/engine.rb
 - lib/flare/filtering_span_processor.rb
 - lib/flare/http_metrics_config.rb
 - lib/flare/http_transport.rb
+- lib/flare/lifecycle.rb
 - lib/flare/marker.rb
 - lib/flare/metric_counter.rb
 - lib/flare/metric_flusher.rb
@@ -208,6 +211,7 @@ files:
 - lib/flare/metric_span_processor.rb
 - lib/flare/metric_storage.rb
 - lib/flare/metric_submitter.rb
+- lib/flare/recording_batch_span_processor.rb
 - lib/flare/rule_manager.rb
 - lib/flare/sampler.rb
 - lib/flare/source_location.rb
@@ -244,7 +248,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.7
+rubygems_version: 4.0.18
 specification_version: 4
 summary: Light up what's slowing you down
 test_files: []