fluyenta-ruby 0.1.14

data/lib/brainzlab/nerve/provisioner.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Nerve
+    class Provisioner
+      def initialize(config)
+        @config = config
+        @provisioned = false
+      end
+
+      def ensure_project!
+        return if @provisioned
+        return unless @config.nerve_auto_provision
+        return unless valid_auth?
+
+        @provisioned = true
+
+        project_id = detect_project_id
+        return unless project_id
+
+        client = Client.new(@config)
+        client.provision(
+          project_id: project_id,
+          app_name: @config.app_name || @config.service
+        )
+
+        BrainzLab.debug_log("[Nerve::Provisioner] Project provisioned: #{project_id}")
+      rescue StandardError => e
+        BrainzLab.debug_log("[Nerve::Provisioner] Provisioning failed: #{e.message}")
+      end
+
+      private
+
+      def valid_auth?
+        key = @config.nerve_api_key || @config.nerve_master_key || @config.secret_key
+        !key.nil? && !key.empty?
+      end
+
+      def detect_project_id
+        ENV.fetch('BRAINZLAB_PROJECT_ID', nil)
+      end
+    end
+  end
+end

data/lib/brainzlab/nerve.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative 'nerve/client'
+require_relative 'nerve/provisioner'
+
+module BrainzLab
+  module Nerve
+    class << self
+      # Report a completed job
+      # @param job_class [String] Job class name
+      # @param job_id [String] Job ID
+      # @param queue [String] Queue name
+      # @param started_at [Time] When job started
+      # @param ended_at [Time] When job ended (defaults to now)
+      # @param attributes [Hash] Additional attributes
+      #
+      # @example
+      #   BrainzLab::Nerve.report_success(
+      #     job_class: "ProcessOrderJob",
+      #     job_id: "abc-123",
+      #     queue: "default",
+      #     started_at: 1.minute.ago
+      #   )
+      #
+      def report_success(job_class:, job_id:, queue:, started_at:, ended_at: Time.now, **attributes)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.report_job(
+          job_class: job_class,
+          job_id: job_id,
+          queue: queue,
+          status: 'completed',
+          started_at: started_at,
+          ended_at: ended_at,
+          **attributes
+        )
+      end
+
+      # Report a failed job
+      def report_failure(job_class:, job_id:, queue:, error:, started_at: nil, **attributes)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.report_failure(
+          job_class: job_class,
+          job_id: job_id,
+          queue: queue,
+          error_class: error.class.name,
+          error_message: error.message,
+          backtrace: error.backtrace,
+          started_at: started_at,
+          **attributes
+        )
+      end
+
+      # Report a job that's currently running
+      def report_started(job_class:, job_id:, queue:, **attributes)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.report_job(
+          job_class: job_class,
+          job_id: job_id,
+          queue: queue,
+          status: 'running',
+          started_at: Time.now,
+          ended_at: Time.now,
+          **attributes
+        )
+      end
+
+      # Get job statistics
+      # @param queue [String] Filter by queue (optional)
+      # @param job_class [String] Filter by job class (optional)
+      # @param period [String] Time period: "1h", "24h", "7d", "30d"
+      def stats(queue: nil, job_class: nil, period: '1h')
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.nerve_valid?
+
+        client.stats(queue: queue, job_class: job_class, period: period)
+      end
+
+      # List recent jobs
+      def jobs(queue: nil, status: nil, limit: 100)
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.nerve_valid?
+
+        client.list_jobs(queue: queue, status: status, limit: limit)
+      end
+
+      # List all queues
+      def queues
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.nerve_valid?
+
+        client.list_queues
+      end
+
+      # Get queue details
+      def queue(name)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.nerve_valid?
+
+        client.get_queue(name)
+      end
+
+      # Retry a failed job
+      def retry(job_id)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.retry_job(job_id)
+      end
+
+      # Delete a job
+      def delete(job_id)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.delete_job(job_id)
+      end
+
+      # Report queue metrics (for custom job backends)
+      def report_metrics(queue:, size:, latency_ms: nil, workers: nil)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.report_metrics(
+          queue: queue,
+          size: size,
+          latency_ms: latency_ms,
+          workers: workers
+        )
+      end
+
+      # Track a job execution (block helper)
+      # @example
+      #   BrainzLab::Nerve.track(job_class: "MyJob", job_id: "123", queue: "default") do
+      #     # job work
+      #   end
+      #
+      def track(job_class:, job_id:, queue: 'default', **attributes)
+        started_at = Time.now
+
+        begin
+          result = yield
+          report_success(
+            job_class: job_class,
+            job_id: job_id,
+            queue: queue,
+            started_at: started_at,
+            **attributes
+          )
+          result
+        rescue StandardError => e
+          report_failure(
+            job_class: job_class,
+            job_id: job_id,
+            queue: queue,
+            error: e,
+            started_at: started_at,
+            **attributes
+          )
+          raise
+        end
+      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 reset!
+        @client = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def enabled?
+        BrainzLab.configuration.nerve_enabled
+      end
+    end
+  end
+end

data/lib/brainzlab/pulse/client.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module BrainzLab
+  module Pulse
+    class Client
+      MAX_RETRIES = 3
+      RETRY_DELAY = 0.5
+
+      def initialize(config)
+        @config = config
+        @buffer = []
+        @mutex = Mutex.new
+        @flush_thread = nil
+      end
+
+      def send_trace(payload)
+        return unless @config.pulse_enabled && @config.pulse_valid?
+
+        if @config.pulse_buffer_size > 1
+          buffer_trace(payload)
+        else
+          post('/api/v1/traces', payload)
+        end
+      end
+
+      def send_batch(payloads)
+        return unless @config.pulse_enabled && @config.pulse_valid?
+        return if payloads.empty?
+
+        post('/api/v1/traces/batch', { traces: payloads })
+      end
+
+      def send_metric(payload)
+        return unless @config.pulse_enabled && @config.pulse_valid?
+
+        post('/api/v1/metrics', payload)
+      end
+
+      def send_span(payload)
+        return unless @config.pulse_enabled && @config.pulse_valid?
+
+        post('/api/v1/spans', payload)
+      end
+
+      def flush
+        traces_to_send = nil
+
+        @mutex.synchronize do
+          return if @buffer.empty?
+
+          traces_to_send = @buffer.dup
+          @buffer.clear
+        end
+
+        send_batch(traces_to_send) if traces_to_send&.any?
+      end
+
+      private
+
+      def buffer_trace(payload)
+        should_flush = false
+
+        @mutex.synchronize do
+          @buffer << payload
+          should_flush = @buffer.size >= @config.pulse_buffer_size
+        end
+
+        start_flush_timer unless @flush_thread&.alive?
+        flush if should_flush
+      end
+
+      def start_flush_timer
+        @flush_thread = Thread.new do
+          loop do
+            sleep(@config.pulse_flush_interval)
+            flush
+          end
+        end
+      end
+
+      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, 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("Pulse 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[: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}")
+      end
+
+      class RetryableError < StandardError; end
+    end
+  end
+end