fluyenta-ruby 0.1.14

data/lib/brainzlab/recall/client.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module BrainzLab
+  module Recall
+    class Client
+      MAX_RETRIES = 3
+      RETRY_DELAY = 0.5
+
+      def initialize(config)
+        @config = config
+        @uri = URI.parse(config.recall_url)
+      end
+
+      def send_log(log_entry)
+        return unless @config.recall_enabled && @config.valid?
+
+        post('/api/v1/log', log_entry)
+      end
+
+      def send_batch(log_entries)
+        return unless @config.recall_enabled && @config.valid?
+        return if log_entries.empty?
+
+        post('/api/v1/logs', { logs: log_entries })
+      end
+
+      private
+
+      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, path)
+      rescue StandardError => e
+        handle_error(e, context: { path: path, body_size: body.to_s.length })
+        nil
+      end
+
+      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'
+          http.open_timeout = 5
+          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
+            begin
+              JSON.parse(response.body)
+            rescue StandardError
+              {}
+            end
+          when 429, 500..599
+            raise RetryableError, "Server error: #{response.code}"
+          else
+            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
+          retries += 1
+          if retries <= MAX_RETRIES
+            sleep(RETRY_DELAY * retries)
+            retry
+          end
+          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::Recall] #{message}")
+      end
+
+      class RetryableError < StandardError; end
+    end
+  end
+end

data/lib/brainzlab/recall/logger.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module BrainzLab
+  module Recall
+    class Logger < ::Logger
+      attr_accessor :broadcast_to
+
+      def initialize(service_name = nil, broadcast_to: nil)
+        super(nil)
+        @service_name = service_name
+        @broadcast_to = broadcast_to
+        @level = ::Logger::DEBUG
+        @formatter = proc { |_severity, _time, _progname, msg| msg }
+      end
+
+      def add(severity, message = nil, progname = nil)
+        severity ||= ::Logger::UNKNOWN
+
+        # Handle block-based messages
+        message = yield if message.nil? && block_given?
+
+        # Handle progname as message (standard Logger behavior)
+        if message.nil?
+          message = progname
+          progname = nil
+        end
+
+        # Broadcast to original logger if configured
+        @broadcast_to&.add(severity, message, progname)
+
+        # Skip if below configured level
+        return true if severity < @level
+
+        level = severity_to_level(severity)
+        return true unless BrainzLab.configuration.level_enabled?(level)
+
+        # Extract structured data if message is a hash
+        data = {}
+        if message.is_a?(Hash)
+          data = message.dup
+          message = data.delete(:message) || data.delete(:msg) || data.to_s
+        end
+
+        data[:service] = @service_name if @service_name
+        data[:progname] = progname if progname
+
+        Recall.log(level, message.to_s, **data)
+        true
+      end
+
+      def debug(message = nil, &)
+        add(::Logger::DEBUG, message, &)
+      end
+
+      def info(message = nil, &)
+        add(::Logger::INFO, message, &)
+      end
+
+      def warn(message = nil, &)
+        add(::Logger::WARN, message, &)
+      end
+
+      def error(message = nil, &)
+        add(::Logger::ERROR, message, &)
+      end
+
+      def fatal(message = nil, &)
+        add(::Logger::FATAL, message, &)
+      end
+
+      def unknown(message = nil, &)
+        add(::Logger::UNKNOWN, message, &)
+      end
+
+      # Rails compatibility methods
+      def silence(severity = ::Logger::ERROR)
+        old_level = @level
+        @level = severity
+        yield self
+      ensure
+        @level = old_level
+      end
+
+      def tagged(*tags)
+        if block_given?
+          BrainzLab.with_context(tags: tags) { yield self }
+        else
+          self
+        end
+      end
+
+      def flush
+        Recall.flush
+      end
+
+      def close
+        flush
+      end
+
+      private
+
+      def severity_to_level(severity)
+        case severity
+        when ::Logger::DEBUG then :debug
+        when ::Logger::INFO then :info
+        when ::Logger::WARN then :warn
+        when ::Logger::ERROR then :error
+        when ::Logger::FATAL, ::Logger::UNKNOWN then :fatal
+        else :info
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/recall/provisioner.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'fileutils'
+
+module BrainzLab
+  module Recall
+    class Provisioner
+      CACHE_DIR = ENV.fetch('BRAINZLAB_CACHE_DIR') { File.join(Dir.home, '.brainzlab') }
+
+      def initialize(config)
+        @config = config
+      end
+
+      def ensure_project!
+        return unless should_provision?
+
+        # Try cached credentials first
+        if (cached = load_cached_credentials)
+          apply_credentials(cached)
+          return cached
+        end
+
+        # Provision new project
+        project = provision_project
+        return unless project
+
+        # Cache and apply credentials
+        cache_credentials(project)
+        apply_credentials(project)
+
+        project
+      end
+
+      private
+
+      def should_provision?
+        if @config.debug
+          log_debug('Checking provision conditions:')
+          log_debug("  recall_auto_provision: #{@config.recall_auto_provision}")
+          log_debug("  app_name: '#{@config.app_name}'")
+          log_debug("  secret_key set: #{@config.secret_key.to_s.strip.length.positive?}")
+          log_debug("  recall_master_key set: #{@config.recall_master_key.to_s.strip.length.positive?}")
+        end
+
+        return false unless @config.recall_auto_provision
+        return false unless @config.app_name.to_s.strip.length.positive?
+        return false if @config.secret_key.to_s.strip.length.positive?
+        return false unless @config.recall_master_key.to_s.strip.length.positive?
+
+        log_debug('Will provision Recall project') if @config.debug
+        true
+      end
+
+      def log_debug(message)
+        if @config.logger
+          @config.logger.info("[BrainzLab::Debug] #{message}")
+        else
+          puts "[BrainzLab::Debug] #{message}"
+        end
+      end
+
+      def provision_project
+        uri = URI.parse("#{@config.recall_url}/api/v1/projects/provision")
+        request = Net::HTTP::Post.new(uri)
+        request['Content-Type'] = 'application/json'
+        request['X-Master-Key'] = @config.recall_master_key
+        request['User-Agent'] = "brainzlab-sdk-ruby/#{BrainzLab::VERSION}"
+        request.body = JSON.generate({ name: @config.app_name })
+
+        response = execute(uri, request)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("Failed to provision Recall project: #{e.message}")
+        nil
+      end
+
+      def load_cached_credentials
+        path = cache_file_path
+        return nil unless File.exist?(path)
+
+        data = JSON.parse(File.read(path), symbolize_names: true)
+
+        # Validate cached data has required keys
+        return nil unless data[:ingest_key]
+
+        data
+      rescue StandardError => e
+        log_error("Failed to load cached credentials: #{e.message}")
+        nil
+      end
+
+      def cache_credentials(project)
+        FileUtils.mkdir_p(CACHE_DIR)
+        File.write(cache_file_path, JSON.generate(project))
+      rescue StandardError => e
+        log_error("Failed to cache credentials: #{e.message}")
+      end
+
+      def cache_file_path
+        File.join(CACHE_DIR, "#{@config.app_name}.recall.json")
+      end
+
+      def apply_credentials(project)
+        @config.secret_key = project[:ingest_key]
+
+        # Also set service name from app_name if not already set
+        @config.service ||= @config.app_name
+      end
+
+      def execute(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = 5
+        http.read_timeout = 10
+        http.request(request)
+      end
+
+      def log_error(message)
+        return unless @config.logger
+
+        @config.logger.error("[BrainzLab] #{message}")
+      end
+    end
+  end
+end

data/lib/brainzlab/recall.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require_relative 'recall/client'
+require_relative 'recall/buffer'
+require_relative 'recall/logger'
+require_relative 'recall/provisioner'
+
+module BrainzLab
+  module Recall
+    class << self
+      def debug(message, **data)
+        log(:debug, message, **data)
+      end
+
+      def info(message, **data)
+        log(:info, message, **data)
+      end
+
+      def warn(message, **data)
+        log(:warn, message, **data)
+      end
+
+      def error(message, **data)
+        log(:error, message, **data)
+      end
+
+      def fatal(message, **data)
+        log(:fatal, message, **data)
+      end
+
+      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.valid?
+
+        buffer.push(entry)
+      end
+
+      def ensure_provisioned!
+        config = BrainzLab.configuration
+        puts "[BrainzLab::Debug] Recall.ensure_provisioned! called, @provisioned=#{@provisioned}" if config.debug
+
+        return if @provisioned
+
+        @provisioned = true
+        provisioner.ensure_project!
+      end
+
+      def provisioner
+        @provisioner ||= Provisioner.new(BrainzLab.configuration)
+      end
+
+      def time(label, **data)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = yield
+        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(1)
+
+        info("#{label} (#{duration_ms}ms)", **data, duration_ms: duration_ms)
+        result
+      end
+
+      def flush
+        buffer.flush
+      end
+
+      def logger(name = nil)
+        Logger.new(name)
+      end
+
+      def client
+        @client ||= Client.new(BrainzLab.configuration)
+      end
+
+      def buffer
+        @buffer ||= Buffer.new(BrainzLab.configuration, client)
+      end
+
+      def reset!
+        @client = nil
+        @buffer = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def build_entry(level, message, data)
+        config = BrainzLab.configuration
+        context = Context.current
+
+        entry = {
+          timestamp: Time.now.utc.iso8601(3),
+          level: level.to_s,
+          message: message.to_s
+        }
+
+        # Add configuration context
+        entry[:environment] = config.environment if config.environment
+        entry[:service] = config.service if config.service
+        entry[:host] = config.host if config.host
+        entry[:commit] = config.commit if config.commit
+        entry[:branch] = config.branch if config.branch
+
+        # Add request context
+        entry[:request_id] = context.request_id if context.request_id
+        entry[:session_id] = context.session_id if context.session_id
+
+        # Merge context data with provided data
+        merged_data = context.data_hash.merge(scrub_data(data))
+        entry[:data] = merged_data unless merged_data.empty?
+
+        entry
+      end
+
+      def scrub_data(data)
+        return data if BrainzLab.configuration.scrub_fields.empty?
+
+        scrub_fields = BrainzLab.configuration.scrub_fields
+        deep_scrub(data, scrub_fields)
+      end
+
+      def deep_scrub(obj, fields)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(key, value), result|
+            result[key] = if should_scrub?(key, fields)
+                            '[FILTERED]'
+                          else
+                            deep_scrub(value, fields)
+                          end
+          end
+        when Array
+          obj.map { |item| deep_scrub(item, fields) }
+        else
+          obj
+        end
+      end
+
+      def should_scrub?(key, fields)
+        key_str = key.to_s.downcase
+        fields.any? do |field|
+          case field
+          when Regexp
+            key_str.match?(field)
+          else
+            key_str == field.to_s.downcase
+          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/breadcrumbs.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Reflex
+    class Breadcrumbs
+      MAX_BREADCRUMBS = 50
+
+      def initialize
+        @breadcrumbs = []
+        @mutex = Mutex.new
+      end
+
+      def add(message:, category: 'default', level: :info, data: nil)
+        crumb = {
+          timestamp: Time.now.utc.iso8601(3),
+          message: message.to_s,
+          category: category.to_s,
+          level: level.to_s
+        }
+        crumb[:data] = data if data
+
+        @mutex.synchronize do
+          @breadcrumbs << crumb
+          @breadcrumbs.shift if @breadcrumbs.size > MAX_BREADCRUMBS
+        end
+      end
+
+      def to_a
+        @mutex.synchronize { @breadcrumbs.dup }
+      end
+
+      def clear!
+        @mutex.synchronize { @breadcrumbs.clear }
+      end
+
+      def size
+        @mutex.synchronize { @breadcrumbs.size }
+      end
+    end
+
+    class << self
+      def breadcrumbs
+        Context.current.breadcrumbs
+      end
+
+      def add_breadcrumb(message, category: 'default', level: :info, data: nil)
+        breadcrumbs.add(message: message, category: category, level: level, data: data)
+      end
+
+      def clear_breadcrumbs!
+        breadcrumbs.clear!
+      end
+    end
+  end
+end