brainzlab 0.1.2 → 0.1.3

data/lib/brainzlab/flux/client.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "json"
-require "uri"
+require 'net/http'
+require 'json'
+require 'uri'
 
 module BrainzLab
   module Flux
@@ -12,23 +12,23 @@ module BrainzLab
       end
 
       def send_event(event)
-        post("/api/v1/events", event)
+        post('/api/v1/events', event)
       end
 
       def send_events(events)
-        post("/api/v1/events/batch", { events: events })
+        post('/api/v1/events/batch', { events: events })
       end
 
       def send_metric(metric)
-        post("/api/v1/metrics", metric)
+        post('/api/v1/metrics', metric)
       end
 
       def send_metrics(metrics)
-        post("/api/v1/metrics/batch", { metrics: metrics })
+        post('/api/v1/metrics/batch', { metrics: metrics })
       end
 
       def send_batch(events:, metrics:)
-        post("/api/v1/flux/batch", { events: events, metrics: metrics })
+        post('/api/v1/flux/batch', { events: events, metrics: metrics })
       end
 
       private
@@ -36,24 +36,22 @@ module BrainzLab
       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.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['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
+        BrainzLab.debug("[Flux] Request failed: #{response.code} - #{response.body}") unless response.is_a?(Net::HTTPSuccess)
 
         response
-      rescue => e
+      rescue StandardError => e
         BrainzLab.debug("[Flux] Request error: #{e.message}")
         nil
       end

data/lib/brainzlab/flux/provisioner.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "json"
-require "uri"
+require 'net/http'
+require 'json'
+require 'uri'
 
 module BrainzLab
   module Flux
@@ -17,7 +17,7 @@ module BrainzLab
         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...")
+        BrainzLab.debug_log('[Flux] Auto-provisioning project...')
         provision_project
       end
 
@@ -26,16 +26,16 @@ module BrainzLab
       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.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['Content-Type'] = 'application/json'
+        request['Authorization'] = "Bearer #{@config.secret_key}"
+        request['User-Agent'] = "brainzlab-sdk/#{BrainzLab::VERSION}"
         request.body = {
-          name: @config.service || "default",
+          name: @config.service || 'default',
           environment: @config.environment
         }.to_json
 
@@ -43,13 +43,13 @@ module BrainzLab
 
         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")
+          @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
+      rescue StandardError => e
         BrainzLab.debug_log("[Flux] Provisioning error: #{e.message}")
       end
     end

data/lib/brainzlab/flux.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "flux/client"
-require_relative "flux/buffer"
-require_relative "flux/provisioner"
+require_relative 'flux/client'
+require_relative 'flux/buffer'
+require_relative 'flux/provisioner'
 
 module BrainzLab
   module Flux
@@ -49,7 +49,7 @@ module BrainzLab
         return unless BrainzLab.configuration.flux_valid?
 
         metric = {
-          type: "gauge",
+          type: 'gauge',
           name: name,
           value: value,
           tags: tags,
@@ -67,7 +67,7 @@ module BrainzLab
         return unless BrainzLab.configuration.flux_valid?
 
         metric = {
-          type: "counter",
+          type: 'counter',
           name: name,
           value: value,
           tags: tags,
@@ -90,7 +90,7 @@ module BrainzLab
         return unless BrainzLab.configuration.flux_valid?
 
         metric = {
-          type: "distribution",
+          type: 'distribution',
           name: name,
           value: value,
           tags: tags,
@@ -108,7 +108,7 @@ module BrainzLab
         return unless BrainzLab.configuration.flux_valid?
 
         metric = {
-          type: "set",
+          type: 'set',
           name: name,
           value: value.to_s,
           tags: tags,
@@ -127,7 +127,7 @@ module BrainzLab
           yield
         ensure
           duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
-          distribution(name, duration_ms, tags: tags.merge(unit: "ms"))
+          distribution(name, duration_ms, tags: tags.merge(unit: 'ms'))
         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
@@ -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
 
@@ -102,9 +102,7 @@ module BrainzLab
           # 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
+            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
@@ -115,7 +113,7 @@ module BrainzLab
         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

data/lib/brainzlab/instrumentation/aws.rb

@@ -9,7 +9,7 @@ module BrainzLab
 
           install_plugin!
 
-          BrainzLab.debug_log("[Instrumentation] AWS SDK instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] AWS SDK instrumentation installed')
         end
 
         private
@@ -22,16 +22,16 @@ module BrainzLab
           end
 
           # Also hook into Seahorse for lower-level tracking
-          if defined?(::Seahorse::Client::Base)
-            install_seahorse_handler!
-          end
+          return unless defined?(::Seahorse::Client::Base)
+
+          install_seahorse_handler!
         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"
+              service = context.client.class.name.split('::')[1] || 'AWS'
               operation = context.operation_name.to_s
 
               begin
@@ -46,12 +46,12 @@ module BrainzLab
 
             private
 
-            def track_success(service, operation, started_at, context, response)
+            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",
+                category: 'aws',
                 level: :info,
                 data: {
                   service: service,
@@ -61,19 +61,19 @@ module BrainzLab
                 }
               )
 
-              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
+              return unless 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
 
-            def track_error(service, operation, started_at, context, error)
-              duration_ms = ((Time.now - started_at) * 1000).round(2)
+            def track_error(service, operation, started_at, _context, error)
+              ((Time.now - started_at) * 1000).round(2)
 
               BrainzLab::Reflex.add_breadcrumb(
                 "AWS #{service}.#{operation} failed: #{error.message}",
-                category: "aws",
+                category: 'aws',
                 level: :error,
                 data: {
                   service: service,
@@ -82,16 +82,16 @@ module BrainzLab
                 }
               )
 
-              if BrainzLab.configuration.flux_effectively_enabled?
-                tags = { service: service, operation: operation, error_class: error.class.name }
-                BrainzLab::Flux.increment("aws.errors", tags: tags)
-              end
+              return unless BrainzLab.configuration.flux_effectively_enabled?
+
+              tags = { service: service, operation: operation, error_class: error.class.name }
+              BrainzLab::Flux.increment('aws.errors', tags: tags)
             end
           end
 
           ::Seahorse::Client::Base.add_plugin(
             Class.new(::Seahorse::Client::Plugin) do
-              define_method(:add_handlers) do |handlers, config|
+              define_method(:add_handlers) do |handlers, _config|
                 handlers.add(handler_class, step: :validate, priority: 0)
               end
             end
@@ -101,7 +101,7 @@ module BrainzLab
 
       # Aws SDK Plugin
       class BrainzLabPlugin
-        def self.add_handlers(handlers, config)
+        def self.add_handlers(handlers, _config)
           handlers.add(Handler, step: :validate, priority: 0)
         end
 
@@ -128,16 +128,20 @@ module BrainzLab
           private
 
           def extract_service(context)
-            context.client.class.name.to_s.split("::")[1] || "AWS"
+            context.client.class.name.to_s.split('::')[1] || 'AWS'
           end
 
-          def track_request(service, operation, started_at, context, response)
+          def track_request(service, operation, started_at, context, _response)
             duration_ms = ((Time.now - started_at) * 1000).round(2)
-            region = context.config.region rescue "unknown"
+            region = begin
+              context.config.region
+            rescue StandardError
+              'unknown'
+            end
 
             BrainzLab::Reflex.add_breadcrumb(
               "AWS #{service}.#{operation}",
-              category: "aws",
+              category: 'aws',
               level: :info,
               data: {
                 service: service,
@@ -148,29 +152,29 @@ module BrainzLab
               }
             )
 
-            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)
+            return unless BrainzLab.configuration.flux_effectively_enabled?
 
-              if context.retries > 0
-                BrainzLab::Flux.increment("aws.retries", value: context.retries, tags: tags)
-              end
-            end
+            tags = { service: service, operation: operation, region: region }
+            BrainzLab::Flux.distribution('aws.duration_ms', duration_ms, tags: tags)
+            BrainzLab::Flux.increment('aws.requests', tags: tags)
+
+            return unless context.retries.positive?
+
+            BrainzLab::Flux.increment('aws.retries', value: context.retries, tags: tags)
           end
 
-          def track_error(service, operation, started_at, context, error)
+          def track_error(service, operation, _started_at, _context, error)
             BrainzLab::Reflex.add_breadcrumb(
               "AWS #{service}.#{operation} failed",
-              category: "aws",
+              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
+            return unless 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

data/lib/brainzlab/instrumentation/dalli.rb

@@ -11,7 +11,7 @@ module BrainzLab
 
           install_client_instrumentation!
 
-          BrainzLab.debug_log("[Instrumentation] Dalli/Memcached instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] Dalli/Memcached instrumentation installed')
         end
 
         private
@@ -54,42 +54,42 @@ module BrainzLab
         # Add breadcrumb
         BrainzLab::Reflex.add_breadcrumb(
           "Memcached #{command.upcase}",
-          category: "cache",
+          category: 'cache',
           level: :info,
           data: { command: command, key: key, duration_ms: duration_ms }
         )
 
         # Track with Flux
-        if BrainzLab.configuration.flux_effectively_enabled?
-          tags = { command: command }
-          BrainzLab::Flux.distribution("memcached.duration_ms", duration_ms, tags: tags)
-          BrainzLab::Flux.increment("memcached.commands", tags: tags)
-
-          # Track cache hits/misses for get commands
-          if command == "get"
-            if result.nil?
-              BrainzLab::Flux.increment("memcached.miss", tags: tags)
-            else
-              BrainzLab::Flux.increment("memcached.hit", tags: tags)
-            end
-          end
+        return unless BrainzLab.configuration.flux_effectively_enabled?
+
+        tags = { command: command }
+        BrainzLab::Flux.distribution('memcached.duration_ms', duration_ms, tags: tags)
+        BrainzLab::Flux.increment('memcached.commands', tags: tags)
+
+        # Track cache hits/misses for get commands
+        return unless command == 'get'
+
+        if result.nil?
+          BrainzLab::Flux.increment('memcached.miss', tags: tags)
+        else
+          BrainzLab::Flux.increment('memcached.hit', tags: tags)
         end
       end
 
       def self.track_error(command, args, started_at, error)
-        duration_ms = ((Time.now - started_at) * 1000).round(2)
+        ((Time.now - started_at) * 1000).round(2)
         key = extract_key(args)
 
         BrainzLab::Reflex.add_breadcrumb(
           "Memcached #{command.upcase} failed: #{error.message}",
-          category: "cache",
+          category: 'cache',
           level: :error,
           data: { command: command, key: key, error: error.class.name }
         )
 
-        if BrainzLab.configuration.flux_effectively_enabled?
-          BrainzLab::Flux.increment("memcached.errors", tags: { command: command })
-        end
+        return unless BrainzLab.configuration.flux_effectively_enabled?
+
+        BrainzLab::Flux.increment('memcached.errors', tags: { command: command })
       end
 
       def self.extract_key(args)