brainzlab 0.1.1 → 0.1.2

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 => 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 > 0
+            rescue => 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,70 @@
+# 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)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          BrainzLab.debug("[Flux] Request failed: #{response.code} - #{response.body}")
+        end
+
+        response
+      rescue => 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 => 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/active_record.rb

@@ -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
@@ -95,6 +95,23 @@ 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
+            if pool.respond_to?(:db_config) && pool.db_config.respond_to?(:name)
+              pool.db_config.name
+            end
+          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
 

data/lib/brainzlab/instrumentation/aws.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module AWSInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Aws)
+
+          install_plugin!
+
+          BrainzLab.debug_log("[Instrumentation] AWS SDK instrumentation installed")
+        end
+
+        private
+
+        def install_plugin!
+          # AWS SDK v3 uses plugins
+          if defined?(::Aws::Plugins)
+            ::Aws.config[:plugins] ||= []
+            ::Aws.config[:plugins] << BrainzLabPlugin unless ::Aws.config[:plugins].include?(BrainzLabPlugin)
+          end
+
+          # Also hook into Seahorse for lower-level tracking
+          if defined?(::Seahorse::Client::Base)
+            install_seahorse_handler!
+          end
+        end
+
+        def install_seahorse_handler!
+          handler_class = Class.new(::Seahorse::Client::Handler) do
+            def call(context)
+              started_at = Time.now
+              service = context.client.class.name.split("::")[1] || "AWS"
+              operation = context.operation_name.to_s
+
+              begin
+                response = @handler.call(context)
+                track_success(service, operation, started_at, context, response)
+                response
+              rescue StandardError => e
+                track_error(service, operation, started_at, context, e)
+                raise
+              end
+            end
+
+            private
+
+            def track_success(service, operation, started_at, context, response)
+              duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+              BrainzLab::Reflex.add_breadcrumb(
+                "AWS #{service}.#{operation}",
+                category: "aws",
+                level: :info,
+                data: {
+                  service: service,
+                  operation: operation,
+                  region: context.config.region,
+                  duration_ms: duration_ms
+                }
+              )
+
+              if BrainzLab.configuration.flux_effectively_enabled?
+                tags = { service: service, operation: operation, region: context.config.region }
+                BrainzLab::Flux.distribution("aws.duration_ms", duration_ms, tags: tags)
+                BrainzLab::Flux.increment("aws.requests", tags: tags)
+              end
+            end
+
+            def track_error(service, operation, started_at, context, error)
+              duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+              BrainzLab::Reflex.add_breadcrumb(
+                "AWS #{service}.#{operation} failed: #{error.message}",
+                category: "aws",
+                level: :error,
+                data: {
+                  service: service,
+                  operation: operation,
+                  error: error.class.name
+                }
+              )
+
+              if BrainzLab.configuration.flux_effectively_enabled?
+                tags = { service: service, operation: operation, error_class: error.class.name }
+                BrainzLab::Flux.increment("aws.errors", tags: tags)
+              end
+            end
+          end
+
+          ::Seahorse::Client::Base.add_plugin(
+            Class.new(::Seahorse::Client::Plugin) do
+              define_method(:add_handlers) do |handlers, config|
+                handlers.add(handler_class, step: :validate, priority: 0)
+              end
+            end
+          )
+        end
+      end
+
+      # Aws SDK Plugin
+      class BrainzLabPlugin
+        def self.add_handlers(handlers, config)
+          handlers.add(Handler, step: :validate, priority: 0)
+        end
+
+        class Handler
+          def initialize(handler)
+            @handler = handler
+          end
+
+          def call(context)
+            started_at = Time.now
+            service = extract_service(context)
+            operation = context.operation_name.to_s
+
+            begin
+              response = @handler.call(context)
+              track_request(service, operation, started_at, context, response)
+              response
+            rescue StandardError => e
+              track_error(service, operation, started_at, context, e)
+              raise
+            end
+          end
+
+          private
+
+          def extract_service(context)
+            context.client.class.name.to_s.split("::")[1] || "AWS"
+          end
+
+          def track_request(service, operation, started_at, context, response)
+            duration_ms = ((Time.now - started_at) * 1000).round(2)
+            region = context.config.region rescue "unknown"
+
+            BrainzLab::Reflex.add_breadcrumb(
+              "AWS #{service}.#{operation}",
+              category: "aws",
+              level: :info,
+              data: {
+                service: service,
+                operation: operation,
+                region: region,
+                duration_ms: duration_ms,
+                retries: context.retries
+              }
+            )
+
+            if BrainzLab.configuration.flux_effectively_enabled?
+              tags = { service: service, operation: operation, region: region }
+              BrainzLab::Flux.distribution("aws.duration_ms", duration_ms, tags: tags)
+              BrainzLab::Flux.increment("aws.requests", tags: tags)
+
+              if context.retries > 0
+                BrainzLab::Flux.increment("aws.retries", value: context.retries, tags: tags)
+              end
+            end
+          end
+
+          def track_error(service, operation, started_at, context, error)
+            BrainzLab::Reflex.add_breadcrumb(
+              "AWS #{service}.#{operation} failed",
+              category: "aws",
+              level: :error,
+              data: { service: service, operation: operation, error: error.class.name }
+            )
+
+            if BrainzLab.configuration.flux_effectively_enabled?
+              tags = { service: service, operation: operation, error_class: error.class.name }
+              BrainzLab::Flux.increment("aws.errors", tags: tags)
+            end
+          end
+        end
+      end
+    end
+  end
+end