flare 0.1.0

data/lib/flare/http_metrics_config.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Flare
+  class HttpMetricsConfig
+    class HostConfig
+      attr_reader :rules
+
+      def initialize
+        @rules = []
+        @all = false
+      end
+
+      def initialize_copy(source)
+        @rules = source.rules.dup
+      end
+
+      def all?
+        @all
+      end
+
+      # Track all paths for this host (normalized via normalize_path)
+      def all
+        @all = true
+      end
+
+      # Track paths matching this regex (normalized via normalize_path)
+      def allow(pattern)
+        @rules << {pattern: pattern, replacement: nil}
+      end
+
+      # Track paths matching this regex with a custom replacement string
+      def map(pattern, replacement)
+        @rules << {pattern: pattern, replacement: replacement}
+      end
+
+      # Returns the resolved path for a given raw path, or "*" if no match.
+      # If :all, returns nil to signal "use normalize_path".
+      # If a rule matches with a replacement, returns the replacement.
+      # If a rule matches without a replacement, returns nil to signal "use normalize_path".
+      # If no rules match, returns "*".
+      def resolve(path)
+        return nil if @all
+
+        @rules.each do |rule|
+          if rule[:pattern].match?(path)
+            return rule[:replacement] # nil means use normalize_path
+          end
+        end
+
+        "*"
+      end
+    end
+
+    def initialize
+      @hosts = {}
+    end
+
+    def initialize_copy(source)
+      @hosts = source.instance_variable_get(:@hosts).transform_values(&:dup)
+    end
+
+    def host(hostname, mode = nil, &block)
+      config = @hosts[hostname] ||= HostConfig.new
+
+      if mode == :all
+        config.all
+      elsif block
+        yield config
+      end
+    end
+
+    # Resolve a host+path to the target path for metrics.
+    # Returns "*" for unknown hosts or unmatched paths.
+    # Returns nil to signal "use normalize_path".
+    # Returns a string for custom replacements.
+    def resolve(hostname, path)
+      host_config = @hosts[hostname]
+      return "*" unless host_config
+
+      host_config.resolve(path)
+    end
+
+    DEFAULT = new.tap do |config|
+      config.host "flare.am" do |h|
+        h.allow %r{/api/metrics}
+      end
+
+      config.host "www.flippercloud.io" do |h|
+        h.map %r{/adapter/features/[^/]+/(boolean|actors|groups|percentage_of_actors|percentage_of_time|expression|clear)}, "/adapter/features/:name/:gate"
+        h.map %r{/adapter/features/[^/]+}, "/adapter/features/:name"
+        h.map %r{/adapter/actors/[^/]+}, "/adapter/actors/:id"
+        h.allow %r{/adapter/features}
+        h.allow %r{/adapter/import}
+        h.allow %r{/adapter/telemetry/summary}
+        h.allow %r{/adapter/telemetry}
+        h.allow %r{/adapter/events}
+        h.allow %r{/adapter/audits}
+      end
+    end.freeze
+  end
+end

data/lib/flare/metric_counter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "concurrent/atomic/atomic_fixnum"
+
+module Flare
+  # Thread-safe counter for metric aggregation.
+  # Uses atomic operations for lock-free increments.
+  #
+  # Note: Durations are stored as integer milliseconds. Sub-millisecond
+  # durations are truncated to 0. For very fast operations (e.g., cache hits),
+  # the sum_ms may undercount actual time spent.
+  class MetricCounter
+    def initialize
+      @count = Concurrent::AtomicFixnum.new(0)
+      @sum_ms = Concurrent::AtomicFixnum.new(0)
+      @error_count = Concurrent::AtomicFixnum.new(0)
+    end
+
+    def increment(duration_ms:, error: false)
+      @count.increment
+      @sum_ms.increment(duration_ms.to_i)
+      @error_count.increment if error
+    end
+
+    def count
+      @count.value
+    end
+
+    def sum_ms
+      @sum_ms.value
+    end
+
+    def error_count
+      @error_count.value
+    end
+
+    def to_h
+      {
+        count: @count.value,
+        sum_ms: @sum_ms.value,
+        error_count: @error_count.value
+      }
+    end
+  end
+end

data/lib/flare/metric_flusher.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "concurrent/timer_task"
+require "concurrent/executor/fixed_thread_pool"
+
+module Flare
+  # Background threads that periodically drain in-memory metrics and submit
+  # them via HTTP. Uses concurrent-ruby TimerTask + FixedThreadPool, matching
+  # the pattern in Flipper's telemetry.
+  #
+  # Fork-safe: detects forked processes and restarts automatically.
+  class MetricFlusher
+    DEFAULT_INTERVAL = 60 # seconds
+    DEFAULT_SHUTDOWN_TIMEOUT = 5 # seconds
+
+    attr_reader :interval, :shutdown_timeout
+
+    def initialize(storage:, submitter:, interval: DEFAULT_INTERVAL, shutdown_timeout: DEFAULT_SHUTDOWN_TIMEOUT)
+      @storage = storage
+      @submitter = submitter
+      @interval = interval
+      @shutdown_timeout = shutdown_timeout
+      @pid = $$
+      @stopped = false
+    end
+
+    def start
+      @stopped = false
+
+      @pool = Concurrent::FixedThreadPool.new(1, {
+        max_queue: 20,
+        fallback_policy: :discard,
+        name: "flare-metrics-submit-pool".freeze,
+      })
+
+      @timer = Concurrent::TimerTask.execute({
+        execution_interval: @interval,
+        name: "flare-metrics-drain-timer".freeze,
+      }) { post_to_pool }
+    end
+
+    def stop
+      return if @stopped
+
+      @stopped = true
+
+      Flare.log "Shutting down metrics flusher, draining remaining metrics..."
+
+      if @timer
+        @timer.shutdown
+        @timer.wait_for_termination(1)
+        @timer.kill unless @timer.shutdown?
+      end
+
+      if @pool
+        post_to_pool # one last drain
+        @pool.shutdown
+        pool_terminated = @pool.wait_for_termination(@shutdown_timeout)
+        @pool.kill unless pool_terminated
+      end
+
+      Flare.log "Metrics flusher stopped"
+    end
+
+    def restart
+      @stopped = false
+      stop
+      start
+    end
+
+    # Manually trigger a flush (useful for testing or forced flushes).
+    def flush_now
+      return 0 unless @storage && @submitter
+
+      drained = @storage.drain
+      return 0 if drained.empty?
+
+      count, error = @submitter.submit(drained)
+      if error
+        warn "[Flare] Metric submission error: #{error.message}"
+      end
+      count
+    rescue => e
+      warn "[Flare] Metric flush error: #{e.message}"
+      0
+    end
+
+    def running?
+      @timer&.running? || false
+    end
+
+    # Re-initialize after fork. Called automatically by MetricSpanProcessor
+    # on first span in the new process, or manually from Puma/Unicorn
+    # after_fork hooks.
+    def after_fork
+      @pid = $$
+      restart
+    end
+
+    private
+
+    def post_to_pool
+      drained = @storage.drain
+      if drained.empty?
+        Flare.log "No metrics to flush"
+        return
+      end
+
+      Flare.log "Drained #{drained.size} metric keys for submission"
+      @pool.post { submit_to_cloud(drained) }
+    rescue => e
+      warn "[Flare] Metric drain error: #{e.message}"
+    end
+
+    def submit_to_cloud(drained)
+      _response, error = @submitter.submit(drained)
+      if error
+        warn "[Flare] Metric submission error: #{error.message}"
+      end
+    rescue => e
+      warn "[Flare] Metric submission error: #{e.message}"
+    end
+  end
+end

data/lib/flare/metric_key.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Flare
+  # Identifies a unique metric for aggregation.
+  # Immutable and hashable for use as Concurrent::Map keys.
+  class MetricKey
+    attr_reader :bucket, :namespace, :service, :target, :operation
+
+    def initialize(bucket:, namespace:, service:, target:, operation:)
+      @bucket = bucket
+      @namespace = namespace.to_s.freeze
+      @service = service.to_s.freeze
+      @target = target&.to_s&.freeze
+      @operation = operation.to_s.freeze
+      freeze
+    end
+
+    def eql?(other)
+      self.class.eql?(other.class) &&
+        bucket == other.bucket &&
+        namespace == other.namespace &&
+        service == other.service &&
+        target == other.target &&
+        operation == other.operation
+    end
+    alias == eql?
+
+    def hash
+      [self.class, bucket, namespace, service, target, operation].hash
+    end
+
+    def to_h
+      {
+        bucket: bucket,
+        namespace: namespace,
+        service: service,
+        target: target,
+        operation: operation
+      }
+    end
+  end
+end