flare 0.4.0 → 1.0.0

data/lib/flare/metric_submitter.rb

@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "json"
-require "zlib"
-require "stringio"
-require "securerandom"
-
-require_relative "client_headers"
-require_relative "deadline"
-
-module Flare
-  # Submits metrics to the Flare metrics service via HTTP.
-  # Handles gzip compression, retries with exponential backoff, and error handling.
-  class MetricSubmitter
-    SCHEMA_VERSION = "V1"
-    GZIP_ENCODING = "gzip"
-
-    # Default timeouts (in seconds)
-    DEFAULT_OPEN_TIMEOUT = 2
-    DEFAULT_READ_TIMEOUT = 5
-    DEFAULT_WRITE_TIMEOUT = 5
-
-    # Max retries before giving up
-    MAX_RETRIES = 3
-
-    class SubmissionError < StandardError
-      attr_reader :request_id, :response_code, :response_body
-
-      def initialize(message, request_id:, response_code: nil, response_body: nil)
-        @request_id = request_id
-        @response_code = response_code
-        @response_body = response_body
-        super(message)
-      end
-    end
-
-    class ClientError < StandardError
-      attr_reader :request_id, :response_code, :response_body
-
-      def initialize(message, request_id:, response_code: nil, response_body: nil)
-        @request_id = request_id
-        @response_code = response_code
-        @response_body = response_body
-        super(message)
-      end
-    end
-
-    class DeadlineExceeded < StandardError; end
-
-    attr_reader :endpoint, :api_key, :backoff_policy
-
-    def initialize(endpoint:, api_key:, project: nil, environment: nil, backoff_policy: nil, open_timeout: nil, read_timeout: nil, write_timeout: nil)
-      @endpoint = URI("#{endpoint.to_s.chomp('/')}/api/metrics")
-      @api_key = api_key
-      @project = project || default_project
-      @environment = environment || default_environment
-      @backoff_policy = backoff_policy || BackoffPolicy.new
-      @open_timeout = open_timeout || DEFAULT_OPEN_TIMEOUT
-      @read_timeout = read_timeout || DEFAULT_READ_TIMEOUT
-      @write_timeout = write_timeout || DEFAULT_WRITE_TIMEOUT
-    end
-
-    # Submit drained metrics to the server.
-    # Returns [success_count, error] where error may be nil on success.
-    def submit(drained, timeout: nil)
-      return [0, nil] if drained.empty?
-
-      deadline = Deadline.new(timeout)
-
-      request_id = SecureRandom.uuid
-      Flare.log "Submitting #{drained.size} metrics to #{@endpoint} (request_id=#{request_id})" if Flare.respond_to?(:log)
-
-      body = build_body(drained, request_id)
-      return [0, nil] if body.nil?
-      return [0, DeadlineExceeded.new("metric submission deadline exceeded")] if deadline.expired?
-
-      @backoff_policy.reset
-      response, error = retry_with_backoff(MAX_RETRIES, deadline: deadline) do
-        post(body, request_id, timeout: deadline.remaining)
-      end
-
-      if error
-        Flare.log "Submission failed: #{error.message} (request_id=#{request_id})" if Flare.respond_to?(:log)
-        [0, error]
-      else
-        Flare.log "Submission succeeded: #{response.code} (request_id=#{request_id})" if Flare.respond_to?(:log)
-        [drained.size, nil]
-      end
-    end
-
-    private
-
-    def build_body(drained, request_id)
-      metrics = drained.map do |key, values|
-        {
-          bucket: format_time(key.bucket),
-          namespace: key.namespace,
-          service: key.service,
-          target: key.target || "",
-          operation: key.operation,
-          count: values[:count],
-          sum_ms: values[:sum_ms],
-          error_count: values[:error_count]
-        }
-      end
-
-      payload = {
-        request_id: request_id,
-        schema_version: SCHEMA_VERSION,
-        project: @project,
-        environment: @environment,
-        metrics: metrics
-      }
-
-      gzip(JSON.generate(payload))
-    rescue => e
-      warn "[Flare] Failed to build submission body: #{e.message}"
-      nil
-    end
-
-    def post(body, request_id, timeout: nil)
-      raise DeadlineExceeded, "metric submission deadline exceeded" if timeout == 0
-
-      http = Net::HTTP.new(@endpoint.host, @endpoint.port)
-      http.use_ssl = @endpoint.scheme == "https"
-      http.open_timeout = effective_timeout(@open_timeout, timeout)
-      http.read_timeout = effective_timeout(@read_timeout, timeout)
-      http.write_timeout = effective_timeout(@write_timeout, timeout) if http.respond_to?(:write_timeout=)
-
-      request_uri = @endpoint.request_uri
-      request = Net::HTTP::Post.new(request_uri == "" ? "/" : request_uri)
-      request["Content-Type"] = "application/json"
-      request["Content-Encoding"] = GZIP_ENCODING
-      request["Authorization"] = "Bearer #{@api_key}"
-      request["X-Request-Id"] = request_id
-      request["X-Schema-Version"] = SCHEMA_VERSION
-
-      # Client + version identifying headers, shared across every Flare-API request.
-      ClientHeaders.to_h.each { |name, value| request[name] = value }
-
-      request.body = body
-      response = http.request(request)
-
-      code = response.code.to_i
-
-      # Success
-      if code >= 200 && code < 300
-        return [response, false] # [result, should_retry]
-      end
-
-      # Retriable errors: rate limiting, server errors
-      if code == 429 || code >= 500
-        raise SubmissionError.new(
-          "Retriable error: #{code}",
-          request_id: request_id,
-          response_code: code,
-          response_body: response.body
-        )
-      end
-
-      # Non-retriable client errors (4xx except 429)
-      raise ClientError.new(
-        "Client error: #{code}",
-        request_id: request_id,
-        response_code: code,
-        response_body: response.body
-      )
-    end
-
-    def retry_with_backoff(max_attempts, deadline:)
-      attempts_remaining = max_attempts
-      last_error = nil
-
-      while attempts_remaining > 0
-        begin
-          return [nil, DeadlineExceeded.new("metric submission deadline exceeded")] if deadline.expired?
-
-          result, should_retry = yield
-          return [nil, DeadlineExceeded.new("metric submission deadline exceeded")] if deadline.expired?
-          return [result, nil] unless should_retry
-        rescue SubmissionError, Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout, Errno::ECONNREFUSED, Errno::ECONNRESET => e
-          last_error = e
-          attempts_remaining -= 1
-
-          if attempts_remaining > 0
-            sleep_time = @backoff_policy.next_interval / 1000.0
-            remaining = deadline.remaining
-            if remaining && sleep_time >= remaining
-              return [nil, DeadlineExceeded.new("metric submission deadline exceeded")]
-            end
-            sleep(sleep_time)
-          end
-          next
-        rescue => e
-          # Unexpected errors - don't retry
-          return [nil, e]
-        end
-      end
-
-      [nil, last_error]
-    end
-
-    def effective_timeout(configured_timeout, remaining)
-      return configured_timeout unless remaining
-
-      [configured_timeout, remaining].min
-    end
-
-    def gzip(string)
-      io = StringIO.new
-      io.set_encoding("BINARY")
-      gz = Zlib::GzipWriter.new(io)
-      gz.write(string)
-      gz.close
-      io.string
-    end
-
-    def format_time(time)
-      time.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
-    end
-
-    def default_project
-      if defined?(Rails) && Rails.application
-        Rails.application.class.module_parent_name.underscore rescue "rails_app"
-      else
-        "app"
-      end
-    end
-
-    def default_environment
-      if defined?(Rails)
-        Rails.env.to_s
-      else
-        ENV.fetch("RACK_ENV", "development")
-      end
-    end
-  end
-end

data/lib/flare/recording_batch_span_processor.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-require "logger"
-require "opentelemetry/sdk"
-
-require_relative "deadline"
-
-module Flare
-  # An asynchronous, bounded span processor that exports every ended recording
-  # span. OpenTelemetry's BatchSpanProcessor only accepts sampled spans, which
-  # excludes RECORD_ONLY spans needed by Flare's local development dashboard.
-  class RecordingBatchSpanProcessor
-    SUCCESS = OpenTelemetry::SDK::Trace::Export::SUCCESS
-    FAILURE = OpenTelemetry::SDK::Trace::Export::FAILURE
-    TIMEOUT = OpenTelemetry::SDK::Trace::Export::TIMEOUT
-
-    def initialize(exporter, exporter_timeout: 30_000, schedule_delay: 5_000,
-                   max_queue_size: 2_048, max_export_batch_size: 512, logger: nil)
-      raise ArgumentError if max_export_batch_size > max_queue_size
-
-      @exporter = exporter
-      @exporter_timeout = exporter_timeout / 1_000.0
-      @schedule_delay = schedule_delay / 1_000.0
-      @max_queue_size = max_queue_size
-      @max_export_batch_size = max_export_batch_size
-      @logger = logger || Logger.new($stderr, level: Logger::WARN)
-      @pid = $$
-      initialize_synchronization
-      start_worker
-    end
-
-    def on_start(_span, _parent_context); end
-
-    def on_finish(span)
-      detect_forking
-
-      @mutex.synchronize do
-        overflow = @queue.length + 1 - @max_queue_size
-        @queue.shift(overflow) if overflow.positive?
-        @queue << span
-        @condition.signal if @queue.length >= @max_export_batch_size
-      end
-    end
-
-    def force_flush(timeout: nil)
-      detect_forking
-      deadline = Deadline.new(timeout)
-      return TIMEOUT unless begin_flush(deadline)
-
-      snapshot = snapshot_for_flush
-      operation = start_flush_export(snapshot, deadline)
-      result = wait_for_flush_export(operation, deadline)
-      [@flush_prior_result, result].max
-    rescue StandardError => e
-      log_export_error(e)
-      FAILURE
-    ensure
-      finish_flush if @flush_owner == Thread.current
-    end
-
-    def shutdown(timeout: nil)
-      detect_forking
-      deadline = Deadline.new(timeout)
-
-      worker = @mutex.synchronize do
-        @stopped = true
-        @condition.broadcast
-        @worker
-      end
-      worker&.join(deadline.remaining)
-      return TIMEOUT if worker&.alive? || deadline.expired?
-
-      result = force_flush(timeout: deadline.remaining)
-      return result unless result == SUCCESS
-      return TIMEOUT if deadline.expired?
-
-      exporter_result = @exporter.shutdown(timeout: deadline.remaining)
-      deadline.expired? ? TIMEOUT : exporter_result
-    rescue StandardError => e
-      log_export_error(e)
-      FAILURE
-    end
-
-    private
-
-    def initialize_synchronization
-      @mutex = Mutex.new
-      @condition = ConditionVariable.new
-      @queue = []
-      @active_exports = 0
-      @export_completion_sequence = 0
-      @last_export_result = SUCCESS
-      @flush_prior_result = SUCCESS
-      @flush_owner = nil
-      @stopped = false
-      @worker = nil
-    end
-
-    def worker_loop
-      loop do
-        batch = @mutex.synchronize do
-          while !@stopped && (@queue.empty? || @flush_owner || @active_exports.positive?)
-            @condition.wait(@mutex, @schedule_delay)
-            break if !@queue.empty? && !@flush_owner && @active_exports.zero?
-          end
-          return if @stopped
-
-          @active_exports += 1
-          @queue.shift(@max_export_batch_size)
-        end
-
-        result = export_batch(batch, timeout: @exporter_timeout)
-      ensure
-        export_finished(result || FAILURE) if batch
-      end
-    end
-
-    def begin_flush(deadline)
-      @mutex.synchronize do
-        initial_sequence = @export_completion_sequence
-        while @flush_owner && @flush_owner != Thread.current
-          return false if deadline.expired?
-
-          @condition.wait(@mutex, deadline.remaining)
-        end
-        @flush_owner = Thread.current
-
-        while @active_exports.positive?
-          return false if deadline.expired?
-
-          @condition.wait(@mutex, deadline.remaining)
-        end
-        @flush_prior_result = if @export_completion_sequence > initial_sequence
-          @last_export_result
-        else
-          SUCCESS
-        end
-      end
-      true
-    end
-
-    def finish_flush
-      @mutex.synchronize do
-        @flush_owner = nil
-        @condition.broadcast
-      end
-    end
-
-    def snapshot_for_flush
-      @mutex.synchronize { @queue.shift(@queue.length) }
-    end
-
-    def export_snapshot(snapshot, deadline)
-      until snapshot.empty?
-        return TIMEOUT if deadline.expired?
-
-        batch = snapshot.shift(@max_export_batch_size)
-        result = export_batch(batch, timeout: deadline.remaining)
-        return result unless result == SUCCESS
-      end
-      SUCCESS
-    ensure
-      @mutex.synchronize { @queue.unshift(*snapshot) } if snapshot&.any?
-    end
-
-    def start_flush_export(snapshot, deadline)
-      operation = { done: false, result: nil }
-      @mutex.synchronize { @active_exports += 1 }
-      Thread.new do
-        result = export_snapshot(snapshot, deadline)
-        if result == SUCCESS && !deadline.expired?
-          result = @exporter.force_flush(timeout: deadline.remaining)
-        end
-        operation[:result] = deadline.expired? ? TIMEOUT : result
-      rescue StandardError => e
-        log_export_error(e)
-        operation[:result] = FAILURE
-      ensure
-        @mutex.synchronize do
-          operation[:done] = true
-          complete_export(operation[:result])
-        end
-      end
-      operation
-    end
-
-    def wait_for_flush_export(operation, deadline)
-      @mutex.synchronize do
-        until operation[:done]
-          return TIMEOUT if deadline.expired?
-
-          @condition.wait(@mutex, deadline.remaining)
-        end
-      end
-      operation[:result]
-    end
-
-    def export_batch(spans, timeout:)
-      span_data = spans.map { |span| span.respond_to?(:to_span_data) ? span.to_span_data : span }
-      @exporter.export(span_data, timeout: timeout)
-    rescue StandardError => e
-      log_export_error(e)
-      FAILURE
-    end
-
-    def export_finished(result)
-      @mutex.synchronize do
-        complete_export(result)
-      end
-    end
-
-    def complete_export(result)
-      @active_exports -= 1
-      @export_completion_sequence += 1
-      @last_export_result = result || FAILURE
-      @condition.broadcast
-    end
-
-    def detect_forking
-      return if @pid == $$
-
-      # Only the forking thread survives. Replacing synchronization objects
-      # avoids waiting on locks or in-flight state owned by vanished threads.
-      @pid = $$
-      initialize_synchronization
-      start_worker
-    end
-
-    def start_worker
-      @worker = Thread.new { worker_loop }
-      @worker.name = "flare-recording-batch-span-processor"
-    end
-
-    def log_export_error(error)
-      @logger.warn("[Flare::RecordingBatchSpanProcessor] export failed: #{error.class}: #{error.message}")
-    end
-  end
-end

data/lib/flare/rule_manager.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "logger"
-require "concurrent/timer_task"
-require "concurrent/atomic/atomic_fixnum"
-
-require_relative "client_headers"
-require_relative "http_transport"
-
-module Flare
-  # The SDK's only poll. Every interval seconds (default 30) it does a
-  # GET /api/rules; the 200 response carries the active TraceRules (with
-  # server-computed sample_rate) plus a bag of presigned R2 PUT URLs.
-  # We hand the rules to Sampler#update_rules and the URLs to
-  # UploadUrlPool#replace, and sweep the Marker so stuck rack-span
-  # entries don't linger.
-  #
-  # ETag-guarded: subsequent polls send If-None-Match. A 304 still gets
-  # us a Marker.sweep but doesn't touch sampler or pool. 401/403 stops
-  # the poller (misconfigured token shouldn't beat down the server).
-  # 5xx and exceptions are logged + counted; the timer just tries again
-  # on the next tick.
-  #
-  # Fork-safe: after_fork clears the pool and restarts the timer in the
-  # child process so each child polls independently.
-  class RuleManager
-    DEFAULT_INTERVAL = 30
-
-    attr_reader :poll_count, :etag, :stopped_due_to_auth, :last_error_count
-
-    def initialize(sampler:, marker:, pool:, base_url:, api_key:, project:, environment:,
-                   interval: DEFAULT_INTERVAL, transport: nil, logger: nil)
-      @sampler     = sampler
-      @marker      = marker
-      @pool        = pool
-      @rules_url   = "#{base_url.to_s.chomp('/')}/api/rules"
-      @api_key     = api_key
-      @project     = project
-      @environment = environment
-      @interval    = interval
-      @transport   = transport || HttpTransport.new
-      @logger      = logger || Logger.new($stderr, level: Logger::WARN)
-
-      @etag = nil
-      @poll_count          = Concurrent::AtomicFixnum.new(0)
-      @last_error_count    = Concurrent::AtomicFixnum.new(0)
-      @stopped_due_to_auth = false
-      @pid                 = $$
-    end
-
-    def start
-      return self if @timer || @stopped_due_to_auth
-
-      @timer = Concurrent::TimerTask.execute(
-        execution_interval: @interval,
-        run_now:            true,
-        name:               "flare-rule-manager-timer"
-      ) { poll_safely }
-      self
-    end
-
-    def stop
-      if @timer
-        @timer.shutdown
-        @timer.wait_for_termination(1)
-        @timer.kill unless @timer.shutdown?
-        @timer = nil
-      end
-      self
-    end
-
-    def running?
-      @timer ? @timer.running? : false
-    end
-
-    def after_fork
-      @pid = $$
-      @pool.after_fork
-      stop
-      start
-    end
-
-    # Public so callers can force a poll (tests + integration tests).
-    def poll_now
-      poll_safely
-    end
-
-    private
-
-    def poll_safely
-      poll
-    rescue StandardError => e
-      @last_error_count.increment
-      @logger.warn("[Flare::RuleManager] poll exception: #{e.class}: #{e.message}")
-    end
-
-    def poll
-      return if @stopped_due_to_auth
-
-      response = @transport.get(@rules_url, request_headers)
-      @poll_count.increment
-
-      case response.code
-      when "304"
-        @marker.sweep
-      when "200"
-        @etag = response.header("ETag")
-        apply(JSON.parse(response.body))
-        @marker.sweep
-      when "401", "403"
-        @stopped_due_to_auth = true
-        @logger.warn("[Flare::RuleManager] auth failed (#{response.code}); stopping poll")
-        stop
-      else
-        @last_error_count.increment
-        @logger.warn("[Flare::RuleManager] unexpected #{response.code}")
-      end
-    end
-
-    def request_headers
-      headers = ClientHeaders.to_h.merge(
-        "Authorization"     => "Bearer #{@api_key}",
-        "Flare-Project"     => @project,
-        "Flare-Environment" => @environment
-      )
-      headers["If-None-Match"] = @etag if @etag
-      headers
-    end
-
-    # Server payload shape (see tirana-v2 Api::RulesController):
-    #   { "trace_rules": [{ "id", "match_attributes", "rate", ..., "urls": [...] }] }
-    def apply(payload)
-      rules = payload["trace_rules"] || []
-      @sampler.update_rules(rules)
-
-      url_entries = rules.flat_map { |r| Array(r["urls"]) }
-      @pool.replace(url_entries)
-    end
-  end
-end