brainzlab 0.1.1 → 0.1.3

data/lib/brainzlab/flux/buffer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Flux
+    class Buffer
+      MAX_EVENTS = 100
+      MAX_METRICS = 100
+      FLUSH_INTERVAL = 5 # seconds
+
+      def initialize(client)
+        @client = client
+        @events = []
+        @metrics = []
+        @mutex = Mutex.new
+        @last_flush = Time.now
+
+        start_flush_thread
+      end
+
+      def add(type, data)
+        @mutex.synchronize do
+          case type
+          when :event
+            @events << data
+          when :metric
+            @metrics << data
+          end
+
+          flush_if_needed
+        end
+      end
+
+      def flush!
+        events_to_send = nil
+        metrics_to_send = nil
+
+        @mutex.synchronize do
+          events_to_send = @events.dup
+          metrics_to_send = @metrics.dup
+          @events.clear
+          @metrics.clear
+          @last_flush = Time.now
+        end
+
+        send_batch(events_to_send, metrics_to_send)
+      end
+
+      def size
+        @mutex.synchronize { @events.size + @metrics.size }
+      end
+
+      private
+
+      def flush_if_needed
+        should_flush = @events.size >= MAX_EVENTS ||
+                       @metrics.size >= MAX_METRICS ||
+                       Time.now - @last_flush >= FLUSH_INTERVAL
+
+        flush_async if should_flush
+      end
+
+      def flush_async
+        events_to_send = @events.dup
+        metrics_to_send = @metrics.dup
+        @events.clear
+        @metrics.clear
+        @last_flush = Time.now
+
+        Thread.new do
+          send_batch(events_to_send, metrics_to_send)
+        end
+      end
+
+      def send_batch(events, metrics)
+        return if events.empty? && metrics.empty?
+
+        @client.send_batch(events: events, metrics: metrics)
+      rescue StandardError => e
+        BrainzLab.debug("[Flux] Batch send failed: #{e.message}")
+      end
+
+      def start_flush_thread
+        Thread.new do
+          loop do
+            sleep FLUSH_INTERVAL
+            begin
+              flush! if size.positive?
+            rescue StandardError => e
+              BrainzLab.debug("[Flux] Flush thread error: #{e.message}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/flux/client.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module BrainzLab
+  module Flux
+    class Client
+      def initialize(config)
+        @config = config
+      end
+
+      def send_event(event)
+        post('/api/v1/events', event)
+      end
+
+      def send_events(events)
+        post('/api/v1/events/batch', { events: events })
+      end
+
+      def send_metric(metric)
+        post('/api/v1/metrics', metric)
+      end
+
+      def send_metrics(metrics)
+        post('/api/v1/metrics/batch', { metrics: metrics })
+      end
+
+      def send_batch(events:, metrics:)
+        post('/api/v1/flux/batch', { events: events, metrics: metrics })
+      end
+
+      private
+
+      def post(path, body)
+        uri = URI.parse("#{base_url}#{path}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = 5
+        http.read_timeout = 10
+
+        request = Net::HTTP::Post.new(uri.path)
+        request['Content-Type'] = 'application/json'
+        request['Authorization'] = "Bearer #{api_key}"
+        request['User-Agent'] = "brainzlab-sdk/#{BrainzLab::VERSION}"
+        request.body = body.to_json
+
+        response = http.request(request)
+
+        BrainzLab.debug("[Flux] Request failed: #{response.code} - #{response.body}") unless response.is_a?(Net::HTTPSuccess)
+
+        response
+      rescue StandardError => e
+        BrainzLab.debug("[Flux] Request error: #{e.message}")
+        nil
+      end
+
+      def base_url
+        @config.flux_url
+      end
+
+      def api_key
+        @config.flux_ingest_key || @config.flux_api_key
+      end
+    end
+  end
+end

data/lib/brainzlab/flux/provisioner.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module BrainzLab
+  module Flux
+    class Provisioner
+      def initialize(config)
+        @config = config
+      end
+
+      def ensure_project!
+        return if (@config.flux_ingest_key && !@config.flux_ingest_key.to_s.empty?) ||
+                  (@config.flux_api_key && !@config.flux_api_key.to_s.empty?)
+        return unless @config.flux_url && !@config.flux_url.to_s.empty?
+        return unless @config.secret_key && !@config.secret_key.to_s.empty?
+
+        BrainzLab.debug_log('[Flux] Auto-provisioning project...')
+        provision_project
+      end
+
+      private
+
+      def provision_project
+        uri = URI.parse("#{@config.flux_url}/api/v1/projects/provision")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = 10
+        http.read_timeout = 30
+
+        request = Net::HTTP::Post.new(uri.path)
+        request['Content-Type'] = 'application/json'
+        request['Authorization'] = "Bearer #{@config.secret_key}"
+        request['User-Agent'] = "brainzlab-sdk/#{BrainzLab::VERSION}"
+        request.body = {
+          name: @config.service || 'default',
+          environment: @config.environment
+        }.to_json
+
+        response = http.request(request)
+
+        if response.is_a?(Net::HTTPSuccess)
+          data = JSON.parse(response.body)
+          @config.flux_ingest_key = data['ingest_key']
+          @config.flux_api_key = data['api_key']
+          BrainzLab.debug_log('[Flux] Project provisioned successfully')
+        else
+          BrainzLab.debug_log("[Flux] Provisioning failed: #{response.code} - #{response.body}")
+        end
+      rescue StandardError => e
+        BrainzLab.debug_log("[Flux] Provisioning error: #{e.message}")
+      end
+    end
+  end
+end

data/lib/brainzlab/flux.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative 'flux/client'
+require_relative 'flux/buffer'
+require_relative 'flux/provisioner'
+
+module BrainzLab
+  module Flux
+    class << self
+      # === EVENTS ===
+
+      # Track a custom event
+      # @param name [String] Event name (e.g., 'user.signup', 'order.completed')
+      # @param properties [Hash] Event properties
+      def track(name, properties = {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        event = {
+          name: name,
+          timestamp: Time.now.utc.iso8601(3),
+          properties: properties.except(:user_id, :value, :tags, :session_id),
+          user_id: properties[:user_id],
+          session_id: properties[:session_id],
+          value: properties[:value],
+          tags: properties[:tags] || {},
+          environment: BrainzLab.configuration.environment,
+          service: BrainzLab.configuration.service
+        }
+
+        buffer.add(:event, event)
+      end
+
+      # Track event for a specific user
+      def track_for_user(user, name, properties = {})
+        user_id = user.respond_to?(:id) ? user.id.to_s : user.to_s
+        track(name, properties.merge(user_id: user_id))
+      end
+
+      # === METRICS ===
+
+      # Gauge: Current value (overwrites)
+      def gauge(name, value, tags: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        metric = {
+          type: 'gauge',
+          name: name,
+          value: value,
+          tags: tags,
+          timestamp: Time.now.utc.iso8601(3)
+        }
+
+        buffer.add(:metric, metric)
+      end
+
+      # Counter: Increment value
+      def increment(name, value = 1, tags: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        metric = {
+          type: 'counter',
+          name: name,
+          value: value,
+          tags: tags,
+          timestamp: Time.now.utc.iso8601(3)
+        }
+
+        buffer.add(:metric, metric)
+      end
+
+      # Counter: Decrement value
+      def decrement(name, value = 1, tags: {})
+        increment(name, -value, tags: tags)
+      end
+
+      # Distribution: Statistical aggregation
+      def distribution(name, value, tags: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        metric = {
+          type: 'distribution',
+          name: name,
+          value: value,
+          tags: tags,
+          timestamp: Time.now.utc.iso8601(3)
+        }
+
+        buffer.add(:metric, metric)
+      end
+
+      # Set: Unique count (cardinality)
+      def set(name, value, tags: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        metric = {
+          type: 'set',
+          name: name,
+          value: value.to_s,
+          tags: tags,
+          timestamp: Time.now.utc.iso8601(3)
+        }
+
+        buffer.add(:metric, metric)
+      end
+
+      # === CONVENIENCE METHODS ===
+
+      # Time a block and record as distribution
+      def measure(name, tags: {})
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        begin
+          yield
+        ensure
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+          distribution(name, duration_ms, tags: tags.merge(unit: 'ms'))
+        end
+      end
+
+      # Flush any buffered data immediately
+      def flush!
+        buffer.flush!
+      end
+
+      # === INTERNAL ===
+
+      def ensure_provisioned!
+        return if @provisioned
+
+        @provisioned = true
+        provisioner.ensure_project!
+      end
+
+      def provisioner
+        @provisioner ||= Provisioner.new(BrainzLab.configuration)
+      end
+
+      def client
+        @client ||= Client.new(BrainzLab.configuration)
+      end
+
+      def buffer
+        @buffer ||= Buffer.new(client)
+      end
+
+      def reset!
+        @client = nil
+        @buffer = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def enabled?
+        BrainzLab.configuration.flux_effectively_enabled?
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/action_mailer.rb

@@ -11,19 +11,19 @@ module BrainzLab
           return if @installed
 
           # Subscribe to deliver notification
-          ActiveSupport::Notifications.subscribe("deliver.action_mailer") do |*args|
+          ActiveSupport::Notifications.subscribe('deliver.action_mailer') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             record_delivery(event)
           end
 
           # Subscribe to process notification (when mail is being prepared)
-          ActiveSupport::Notifications.subscribe("process.action_mailer") do |*args|
+          ActiveSupport::Notifications.subscribe('process.action_mailer') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             record_process(event)
           end
 
           @installed = true
-          BrainzLab.debug_log("ActionMailer instrumentation installed")
+          BrainzLab.debug_log('ActionMailer instrumentation installed')
         end
 
         def installed?
@@ -46,13 +46,13 @@ module BrainzLab
           mail = payload[:mail]
           to = sanitize_recipients(mail&.to)
           subject = mail&.subject
-          delivery_method = payload[:perform_deliveries] ? "delivered" : "skipped"
+          delivery_method = payload[:perform_deliveries] ? 'delivered' : 'skipped'
 
           # Add breadcrumb for Reflex
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "Mail #{delivery_method}: #{mailer}",
-              category: "mailer.deliver",
+              category: 'mailer.deliver',
               level: :info,
               data: {
                 mailer: mailer,
@@ -67,13 +67,13 @@ module BrainzLab
           # Record span for Pulse
           record_span(
             name: "Mail deliver #{mailer}",
-            kind: "mailer",
+            kind: 'mailer',
             started_at: event.time,
             ended_at: event.end,
             duration_ms: duration_ms,
             data: {
               mailer: mailer,
-              action: "deliver",
+              action: 'deliver',
               to: to,
               subject: truncate_subject(subject),
               message_id: message_id,
@@ -106,7 +106,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "Mail process: #{mailer}##{action}",
-              category: "mailer.process",
+              category: 'mailer.process',
               level: :info,
               data: {
                 mailer: mailer,
@@ -119,7 +119,7 @@ module BrainzLab
           # Record span for Pulse
           record_span(
             name: "Mail process #{mailer}##{action}",
-            kind: "mailer",
+            kind: 'mailer',
             started_at: event.time,
             ended_at: event.end,
             duration_ms: duration_ms,
@@ -152,27 +152,28 @@ module BrainzLab
 
           case recipients
           when Array
-            recipients.map { |r| mask_email(r) }.join(", ")
+            recipients.map { |r| mask_email(r) }.join(', ')
           else
             mask_email(recipients.to_s)
           end
         end
 
         def mask_email(email)
-          return email unless email.include?("@")
+          return email unless email.include?('@')
 
-          local, domain = email.split("@", 2)
+          local, domain = email.split('@', 2)
           if local.length > 2
             "#{local[0..1]}***@#{domain}"
           else
             "***@#{domain}"
           end
         rescue StandardError
-          "[email]"
+          '[email]'
         end
 
         def truncate_subject(subject)
           return nil unless subject
+
           subject.to_s[0, 100]
         end
       end

data/lib/brainzlab/instrumentation/active_record.rb

@@ -3,7 +3,7 @@
 module BrainzLab
   module Instrumentation
     class ActiveRecord
-      SCHEMA_QUERIES = ["SCHEMA", "EXPLAIN"].freeze
+      SCHEMA_QUERIES = %w[SCHEMA EXPLAIN].freeze
       INTERNAL_TABLES = %w[pg_ information_schema sqlite_ mysql.].freeze
 
       class << self
@@ -11,7 +11,7 @@ module BrainzLab
           return unless defined?(::ActiveRecord)
           return if @installed
 
-          ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+          ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             next if skip_query?(event.payload)
 
@@ -19,7 +19,7 @@ module BrainzLab
           end
 
           @installed = true
-          BrainzLab.debug_log("ActiveRecord breadcrumbs installed")
+          BrainzLab.debug_log('ActiveRecord breadcrumbs installed')
         end
 
         def installed?
@@ -31,7 +31,7 @@ module BrainzLab
         def record_breadcrumb(event)
           payload = event.payload
           sql = payload[:sql]
-          name = payload[:name] || "SQL"
+          name = payload[:name] || 'SQL'
           duration = event.duration.round(2)
 
           # Extract operation type from SQL
@@ -61,7 +61,7 @@ module BrainzLab
               sql: truncate_sql(sql),
               duration_ms: duration,
               cached: payload[:cached] || false,
-              connection_name: payload[:connection]&.pool&.connection_class&.name
+              connection_name: extract_connection_name(payload[:connection])
             }.compact
           )
         rescue StandardError => e
@@ -69,15 +69,15 @@ module BrainzLab
         end
 
         def extract_operation(sql)
-          return "query" unless sql
+          return 'query' unless sql
 
           case sql.to_s.strip.upcase
-          when /\ASELECT/i then "select"
-          when /\AINSERT/i then "insert"
-          when /\AUPDATE/i then "update"
-          when /\ADELETE/i then "delete"
-          when /\ABEGIN/i, /\ACOMMIT/i, /\AROLLBACK/i then "transaction"
-          else "query"
+          when /\ASELECT/i then 'select'
+          when /\AINSERT/i then 'insert'
+          when /\AUPDATE/i then 'update'
+          when /\ADELETE/i then 'delete'
+          when /\ABEGIN/i, /\ACOMMIT/i, /\AROLLBACK/i then 'transaction'
+          else 'query'
           end
         end
 
@@ -95,10 +95,25 @@ module BrainzLab
           false
         end
 
+        def extract_connection_name(connection)
+          return nil unless connection
+
+          # Rails 8.1+ uses db_config.name on the pool
+          # Older versions used connection_class but that's removed in Rails 8.1
+          if connection.respond_to?(:pool)
+            pool = connection.pool
+            pool.db_config.name if pool.respond_to?(:db_config) && pool.db_config.respond_to?(:name)
+          elsif connection.respond_to?(:db_config) && connection.db_config.respond_to?(:name)
+            connection.db_config.name
+          end
+        rescue StandardError
+          nil
+        end
+
         def truncate_sql(sql)
           return nil unless sql
 
-          truncated = sql.to_s.gsub(/\s+/, " ").strip
+          truncated = sql.to_s.gsub(/\s+/, ' ').strip
           if truncated.length > 500
             "#{truncated[0, 497]}..."
           else