brainzlab 0.1.10 → 0.1.12

data/lib/brainzlab/pulse/client.rb

@@ -84,20 +84,29 @@ module BrainzLab
 
       def post(path, body)
         uri = URI.join(@config.pulse_url, path)
+
+        # Call on_send callback if configured
+        invoke_on_send(:pulse, :post, path, body)
+
+        # Log debug output for request
+        log_debug_request(path, body)
+
         request = Net::HTTP::Post.new(uri)
         request['Content-Type'] = 'application/json'
         request['Authorization'] = "Bearer #{@config.pulse_auth_key}"
         request['User-Agent'] = "brainzlab-sdk-ruby/#{BrainzLab::VERSION}"
         request.body = JSON.generate(body)
 
-        execute_with_retry(uri, request)
+        execute_with_retry(uri, request, path)
       rescue StandardError => e
-        log_error("Failed to send to Pulse: #{e.message}")
+        handle_error(e, context: { path: path, body_size: body.to_s.length })
         nil
       end
 
-      def execute_with_retry(uri, request)
+      def execute_with_retry(uri, request, path)
         retries = 0
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
         begin
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = uri.scheme == 'https'
@@ -105,6 +114,10 @@ module BrainzLab
           http.read_timeout = 10
 
           response = http.request(request)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+
+          # Log debug output for response
+          log_debug_response(response.code.to_i, duration_ms)
 
           case response.code.to_i
           when 200..299
@@ -116,7 +129,10 @@ module BrainzLab
           when 429, 500..599
             raise RetryableError, "Server error: #{response.code}"
           else
-            log_error("Pulse API error: #{response.code} - #{response.body}")
+            handle_error(
+              StandardError.new("Pulse API error: #{response.code}"),
+              context: { path: path, status: response.code, body: response.body }
+            )
             nil
           end
         rescue RetryableError, Net::OpenTimeout, Net::ReadTimeout => e
@@ -125,12 +141,57 @@ module BrainzLab
             sleep(RETRY_DELAY * retries)
             retry
           end
-          log_error("Failed after #{MAX_RETRIES} retries: #{e.message}")
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+          log_debug_response(0, duration_ms, error: e.message)
+          handle_error(e, context: { path: path, retries: retries })
           nil
         end
       end
 
+      def log_debug_request(path, body)
+        return unless BrainzLab::Debug.enabled?
+
+        data = if body.is_a?(Hash) && body[:traces]
+                 { count: body[:traces].size }
+               elsif body.is_a?(Hash) && body[:name]
+                 { name: body[:name] }
+               else
+                 {}
+               end
+
+        BrainzLab::Debug.log_request(:pulse, 'POST', path, data: data)
+      end
+
+      def log_debug_response(status, duration_ms, error: nil)
+        return unless BrainzLab::Debug.enabled?
+
+        BrainzLab::Debug.log_response(:pulse, status, duration_ms, error: error)
+      end
+
+      def invoke_on_send(service, method, path, payload)
+        return unless @config.on_send
+
+        @config.on_send.call(service, method, path, payload)
+      rescue StandardError => e
+        # Don't let callback errors break the SDK
+        log_error("on_send callback error: #{e.message}")
+      end
+
+      def handle_error(error, context: {})
+        log_error("#{error.message}")
+
+        # Call on_error callback if configured
+        return unless @config.on_error
+
+        @config.on_error.call(error, context.merge(service: :pulse))
+      rescue StandardError => e
+        # Don't let callback errors break the SDK
+        log_error("on_error callback error: #{e.message}")
+      end
+
       def log_error(message)
+        BrainzLab::Debug.log(message, level: :error) if BrainzLab::Debug.enabled?
+
         return unless @config.logger
 
         @config.logger.error("[BrainzLab::Pulse] #{message}")

data/lib/brainzlab/pulse.rb

@@ -47,10 +47,17 @@ module BrainzLab
       def record_trace(name, started_at:, ended_at:, kind: 'request', **attributes)
         return unless enabled?
 
+        payload = build_trace_payload(name, kind, started_at, ended_at, attributes)
+
+        # In development mode, log locally instead of sending to server
+        if BrainzLab.configuration.development_mode?
+          Development.record(service: :pulse, event_type: 'trace', payload: payload)
+          return
+        end
+
         ensure_provisioned!
         return unless BrainzLab.configuration.pulse_valid?
 
-        payload = build_trace_payload(name, kind, started_at, ended_at, attributes)
         client.send_trace(payload)
       end
 
@@ -58,9 +65,6 @@ module BrainzLab
       def record_metric(name, value:, kind: 'gauge', tags: {})
         return unless enabled?
 
-        ensure_provisioned!
-        return unless BrainzLab.configuration.pulse_valid?
-
         payload = {
           name: name,
           value: value,
@@ -69,6 +73,15 @@ module BrainzLab
           tags: tags
         }
 
+        # In development mode, log locally instead of sending to server
+        if BrainzLab.configuration.development_mode?
+          Development.record(service: :pulse, event_type: 'metric', payload: payload)
+          return
+        end
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.pulse_valid?
+
         client.send_metric(payload)
       end
 

data/lib/brainzlab/recall/client.rb

@@ -32,20 +32,29 @@ module BrainzLab
 
       def post(path, body)
         uri = URI.join(@config.recall_url, path)
+
+        # Call on_send callback if configured
+        invoke_on_send(:recall, :post, path, body)
+
+        # Log debug output for request
+        log_debug_request(path, body)
+
         request = Net::HTTP::Post.new(uri)
         request['Content-Type'] = 'application/json'
         request['Authorization'] = "Bearer #{@config.secret_key}"
         request['User-Agent'] = "brainzlab-sdk-ruby/#{BrainzLab::VERSION}"
         request.body = JSON.generate(body)
 
-        execute_with_retry(uri, request)
+        execute_with_retry(uri, request, path)
       rescue StandardError => e
-        log_error("Failed to send to Recall: #{e.message}")
+        handle_error(e, context: { path: path, body_size: body.to_s.length })
         nil
       end
 
-      def execute_with_retry(uri, request)
+      def execute_with_retry(uri, request, path)
         retries = 0
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
         begin
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = uri.scheme == 'https'
@@ -53,6 +62,10 @@ module BrainzLab
           http.read_timeout = 10
 
           response = http.request(request)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+
+          # Log debug output for response
+          log_debug_response(response.code.to_i, duration_ms)
 
           case response.code.to_i
           when 200..299
@@ -64,7 +77,10 @@ module BrainzLab
           when 429, 500..599
             raise RetryableError, "Server error: #{response.code}"
           else
-            log_error("Recall API error: #{response.code} - #{response.body}")
+            handle_error(
+              StandardError.new("Recall API error: #{response.code}"),
+              context: { path: path, status: response.code, body: response.body }
+            )
             nil
           end
         rescue RetryableError, Net::OpenTimeout, Net::ReadTimeout => e
@@ -73,15 +89,67 @@ module BrainzLab
             sleep(RETRY_DELAY * retries)
             retry
           end
-          log_error("Failed after #{MAX_RETRIES} retries: #{e.message}")
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+          log_debug_response(0, duration_ms, error: e.message)
+          handle_error(e, context: { path: path, retries: retries })
           nil
         end
       end
 
+      def log_debug_request(path, body)
+        return unless BrainzLab::Debug.enabled?
+
+        data = if body.is_a?(Hash) && body[:logs]
+                 { count: body[:logs].size }
+               elsif body.is_a?(Hash) && body[:message]
+                 { message: body[:message] }
+               else
+                 {}
+               end
+
+        BrainzLab::Debug.log_request(:recall, 'POST', path, data: data)
+      end
+
+      def log_debug_response(status, duration_ms, error: nil)
+        return unless BrainzLab::Debug.enabled?
+
+        BrainzLab::Debug.log_response(:recall, status, duration_ms, error: error)
+      end
+
+      def invoke_on_send(service, method, path, payload)
+        return unless @config.on_send
+
+        @config.on_send.call(service, method, path, payload)
+      rescue StandardError => e
+        # Don't let callback errors break the SDK
+        log_error("on_send callback error: #{e.message}")
+      end
+
+      def handle_error(error, context: {})
+        # Wrap the error in a structured error if it's not already one
+        structured_error = if error.is_a?(BrainzLab::Error)
+                             error
+                           else
+                             ErrorHandler.wrap(error, service: 'Recall', operation: context[:path] || 'unknown')
+                           end
+
+        log_error(structured_error.message)
+
+        # Call on_error callback if configured
+        return unless @config.on_error
+
+        @config.on_error.call(structured_error, context.merge(service: :recall))
+      rescue StandardError => e
+        # Don't let callback errors break the SDK
+        log_error("on_error callback error: #{e.message}")
+      end
+
       def log_error(message)
+        BrainzLab::Debug.log(message, level: :error) if BrainzLab::Debug.enabled?
+
         return unless @config.logger
 
-        @config.logger.error("[BrainzLab] #{message}")
+        @config.logger.error("[BrainzLab::Recall] #{message}")
       end
 
       class RetryableError < StandardError; end

data/lib/brainzlab/recall.rb

@@ -31,14 +31,24 @@ module BrainzLab
       def log(level, message, **data)
         config = BrainzLab.configuration
         return unless config.recall_effectively_enabled?
+        return unless config.level_enabled?(level)
+
+        entry = build_entry(level, message, data)
+
+        # Log debug output for the operation
+        log_debug_operation(level, message, data)
+
+        # In development mode, log locally instead of sending to server
+        if config.development_mode?
+          Development.record(service: :recall, event_type: 'log', payload: entry)
+          return
+        end
 
         # Auto-provision project on first log if app_name is configured
         ensure_provisioned!
 
-        return unless config.level_enabled?(level)
         return unless config.valid?
 
-        entry = build_entry(level, message, data)
         buffer.push(entry)
       end
 
@@ -153,6 +163,13 @@ module BrainzLab
           end
         end
       end
+
+      def log_debug_operation(level, message, data)
+        return unless BrainzLab::Debug.enabled?
+
+        truncated_message = message.to_s.length > 50 ? "#{message.to_s[0..47]}..." : message.to_s
+        BrainzLab::Debug.log_operation(:recall, "#{level.to_s.upcase} \"#{truncated_message}\"", **data.slice(*data.keys.first(3)))
+      end
     end
   end
 end

data/lib/brainzlab/reflex/client.rb

@@ -31,20 +31,29 @@ module BrainzLab
 
       def post(path, body)
         uri = URI.join(@config.reflex_url, path)
+
+        # Call on_send callback if configured
+        invoke_on_send(:reflex, :post, path, body)
+
+        # Log debug output for request
+        log_debug_request(path, body)
+
         request = Net::HTTP::Post.new(uri)
         request['Content-Type'] = 'application/json'
         request['Authorization'] = "Bearer #{@config.reflex_auth_key}"
         request['User-Agent'] = "brainzlab-sdk-ruby/#{BrainzLab::VERSION}"
         request.body = JSON.generate(body)
 
-        execute_with_retry(uri, request)
+        execute_with_retry(uri, request, path)
       rescue StandardError => e
-        log_error("Failed to send to Reflex: #{e.message}")
+        handle_error(e, context: { path: path, body_size: body.to_s.length })
         nil
       end
 
-      def execute_with_retry(uri, request)
+      def execute_with_retry(uri, request, path)
         retries = 0
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
         begin
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = uri.scheme == 'https'
@@ -52,6 +61,10 @@ module BrainzLab
           http.read_timeout = 10
 
           response = http.request(request)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+
+          # Log debug output for response
+          log_debug_response(response.code.to_i, duration_ms)
 
           case response.code.to_i
           when 200..299
@@ -63,7 +76,10 @@ module BrainzLab
           when 429, 500..599
             raise RetryableError, "Server error: #{response.code}"
           else
-            log_error("Reflex API error: #{response.code} - #{response.body}")
+            handle_error(
+              StandardError.new("Reflex API error: #{response.code}"),
+              context: { path: path, status: response.code, body: response.body }
+            )
             nil
           end
         rescue RetryableError, Net::OpenTimeout, Net::ReadTimeout => e
@@ -72,12 +88,57 @@ module BrainzLab
             sleep(RETRY_DELAY * retries)
             retry
           end
-          log_error("Failed after #{MAX_RETRIES} retries: #{e.message}")
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+          log_debug_response(0, duration_ms, error: e.message)
+          handle_error(e, context: { path: path, retries: retries })
           nil
         end
       end
 
+      def log_debug_request(path, body)
+        return unless BrainzLab::Debug.enabled?
+
+        data = if body.is_a?(Hash) && body[:errors]
+                 { count: body[:errors].size }
+               elsif body.is_a?(Hash) && body[:exception]
+                 { exception: body[:exception][:type] }
+               else
+                 {}
+               end
+
+        BrainzLab::Debug.log_request(:reflex, 'POST', path, data: data)
+      end
+
+      def log_debug_response(status, duration_ms, error: nil)
+        return unless BrainzLab::Debug.enabled?
+
+        BrainzLab::Debug.log_response(:reflex, status, duration_ms, error: error)
+      end
+
+      def invoke_on_send(service, method, path, payload)
+        return unless @config.on_send
+
+        @config.on_send.call(service, method, path, payload)
+      rescue StandardError => e
+        # Don't let callback errors break the SDK
+        log_error("on_send callback error: #{e.message}")
+      end
+
+      def handle_error(error, context: {})
+        log_error("#{error.message}")
+
+        # Call on_error callback if configured
+        return unless @config.on_error
+
+        @config.on_error.call(error, context.merge(service: :reflex))
+      rescue StandardError => e
+        # Don't let callback errors break the SDK
+        log_error("on_error callback error: #{e.message}")
+      end
+
       def log_error(message)
+        BrainzLab::Debug.log(message, level: :error) if BrainzLab::Debug.enabled?
+
         return unless @config.logger
 
         @config.logger.error("[BrainzLab::Reflex] #{message}")

data/lib/brainzlab/reflex.rb

@@ -15,15 +15,24 @@ module BrainzLab
         return if excluded?(exception)
         return if sampled_out?
 
-        # Auto-provision project on first capture if app_name is configured
-        ensure_provisioned!
-
-        return unless BrainzLab.configuration.reflex_valid?
+        # Log debug output for the operation
+        log_debug_capture(exception)
 
         payload = build_payload(exception, context)
         payload = run_before_send(payload, exception)
         return if payload.nil?
 
+        # In development mode, log locally instead of sending to server
+        if BrainzLab.configuration.development_mode?
+          Development.record(service: :reflex, event_type: 'error', payload: payload)
+          return
+        end
+
+        # Auto-provision project on first capture if app_name is configured
+        ensure_provisioned!
+
+        return unless BrainzLab.configuration.reflex_valid?
+
         client.send_error(payload)
       end
 
@@ -32,15 +41,24 @@ module BrainzLab
         return if capture_disabled?
         return if sampled_out?
 
-        # Auto-provision project on first capture if app_name is configured
-        ensure_provisioned!
-
-        return unless BrainzLab.configuration.reflex_valid?
+        # Log debug output for the operation
+        log_debug_message(message, level)
 
         payload = build_message_payload(message, level, context)
         payload = run_before_send(payload, nil)
         return if payload.nil?
 
+        # In development mode, log locally instead of sending to server
+        if BrainzLab.configuration.development_mode?
+          Development.record(service: :reflex, event_type: 'message', payload: payload)
+          return
+        end
+
+        # Auto-provision project on first capture if app_name is configured
+        ensure_provisioned!
+
+        return unless BrainzLab.configuration.reflex_valid?
+
         client.send_error(payload)
       end
 
@@ -384,6 +402,20 @@ module BrainzLab
           frame
         end
       end
+
+      def log_debug_capture(exception)
+        return unless BrainzLab::Debug.enabled?
+
+        truncated_message = exception.message.to_s.length > 40 ? "#{exception.message.to_s[0..37]}..." : exception.message.to_s
+        BrainzLab::Debug.log_operation(:reflex, "capture #{exception.class.name}: \"#{truncated_message}\"")
+      end
+
+      def log_debug_message(message, level)
+        return unless BrainzLab::Debug.enabled?
+
+        truncated_message = message.to_s.length > 40 ? "#{message.to_s[0..37]}..." : message.to_s
+        BrainzLab::Debug.log_operation(:reflex, "message [#{level.to_s.upcase}] \"#{truncated_message}\"")
+      end
     end
   end
 end

data/lib/brainzlab/sentinel/client.rb

@@ -209,7 +209,27 @@ module BrainzLab
       end
 
       def log_error(operation, error)
-        BrainzLab.debug_log("[Sentinel::Client] #{operation} failed: #{error.message}")
+        structured_error = ErrorHandler.wrap(error, service: 'Sentinel', operation: operation)
+        BrainzLab.debug_log("[Sentinel::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Sentinel', operation: operation })
+        end
+      end
+
+      def handle_response_error(response, operation)
+        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated) || response.is_a?(Net::HTTPNoContent) || response.is_a?(Net::HTTPAccepted)
+
+        structured_error = ErrorHandler.from_response(response, service: 'Sentinel', operation: operation)
+        BrainzLab.debug_log("[Sentinel::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Sentinel', operation: operation })
+        end
+
+        structured_error
       end
     end
   end

data/lib/brainzlab/synapse/client.rb

@@ -281,7 +281,27 @@ module BrainzLab
       end
 
       def log_error(operation, error)
-        BrainzLab.debug_log("[Synapse::Client] #{operation} failed: #{error.message}")
+        structured_error = ErrorHandler.wrap(error, service: 'Synapse', operation: operation)
+        BrainzLab.debug_log("[Synapse::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Synapse', operation: operation })
+        end
+      end
+
+      def handle_response_error(response, operation)
+        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated) || response.is_a?(Net::HTTPNoContent) || response.is_a?(Net::HTTPAccepted)
+
+        structured_error = ErrorHandler.from_response(response, service: 'Synapse', operation: operation)
+        BrainzLab.debug_log("[Synapse::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Synapse', operation: operation })
+        end
+
+        structured_error
       end
     end
   end