brainzlab 0.1.0 → 0.1.2

data/lib/brainzlab/instrumentation/stripe.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module StripeInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Stripe)
+
+          install_instrumentation!
+
+          BrainzLab.debug_log("[Instrumentation] Stripe instrumentation installed")
+        end
+
+        private
+
+        def install_instrumentation!
+          # Stripe uses a request callback system
+          if ::Stripe.respond_to?(:add_instrumentation)
+            ::Stripe.add_instrumentation do |event|
+              track_event(event)
+            end
+          else
+            # Fallback: monkey-patch the API resource
+            install_api_resource_patch!
+          end
+        end
+
+        def install_api_resource_patch!
+          return unless defined?(::Stripe::StripeClient)
+          return unless ::Stripe::StripeClient.respond_to?(:execute_request)
+
+          ::Stripe::StripeClient.class_eval do
+            class << self
+              alias_method :original_execute_request, :execute_request
+
+              def execute_request(method, path, api_base: nil, api_key: nil, headers: {}, params: {}, usage: [])
+                started_at = Time.now
+                resource = extract_resource(path)
+
+                begin
+                  response = original_execute_request(
+                    method, path,
+                    api_base: api_base,
+                    api_key: api_key,
+                    headers: headers,
+                    params: params,
+                    usage: usage
+                  )
+
+                  BrainzLab::Instrumentation::StripeInstrumentation.track_success(
+                    method, resource, path, started_at, response
+                  )
+
+                  response
+                rescue StandardError => e
+                  BrainzLab::Instrumentation::StripeInstrumentation.track_error(
+                    method, resource, path, started_at, e
+                  )
+                  raise
+                end
+              end
+
+              def extract_resource(path)
+                # /v1/customers/cus_xxx -> customers
+                parts = path.to_s.split("/").reject(&:empty?)
+                parts[1] || "unknown"
+              end
+            end
+          end
+        end
+
+        def track_event(event)
+          duration_ms = (event[:duration] * 1000).round(2) if event[:duration]
+          method = event[:method].to_s.upcase
+          resource = event[:path].to_s.split("/")[2] || "unknown"
+
+          BrainzLab::Reflex.add_breadcrumb(
+            "Stripe #{method} #{resource}",
+            category: "payment",
+            level: event[:error] ? :error : :info,
+            data: {
+              method: method,
+              resource: resource,
+              status: event[:http_status],
+              duration_ms: duration_ms,
+              request_id: event[:request_id]
+            }
+          )
+
+          if BrainzLab.configuration.flux_effectively_enabled?
+            tags = { method: method, resource: resource }
+            BrainzLab::Flux.distribution("stripe.duration_ms", duration_ms, tags: tags) if duration_ms
+            BrainzLab::Flux.increment("stripe.requests", tags: tags)
+
+            if event[:error]
+              BrainzLab::Flux.increment("stripe.errors", tags: tags.merge(error_type: event[:error_type]))
+            end
+          end
+        end
+      end
+
+      def self.track_success(method, resource, path, started_at, response)
+        duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+        BrainzLab::Reflex.add_breadcrumb(
+          "Stripe #{method.to_s.upcase} #{resource}",
+          category: "payment",
+          level: :info,
+          data: {
+            method: method.to_s.upcase,
+            resource: resource,
+            path: path,
+            duration_ms: duration_ms
+          }
+        )
+
+        if BrainzLab.configuration.flux_effectively_enabled?
+          tags = { method: method.to_s.upcase, resource: resource }
+          BrainzLab::Flux.distribution("stripe.duration_ms", duration_ms, tags: tags)
+          BrainzLab::Flux.increment("stripe.requests", tags: tags)
+        end
+      end
+
+      def self.track_error(method, resource, path, started_at, error)
+        duration_ms = ((Time.now - started_at) * 1000).round(2)
+        error_type = case error
+                     when Stripe::CardError then "card_error"
+                     when Stripe::RateLimitError then "rate_limit"
+                     when Stripe::InvalidRequestError then "invalid_request"
+                     when Stripe::AuthenticationError then "authentication"
+                     when Stripe::APIConnectionError then "connection"
+                     when Stripe::StripeError then "stripe_error"
+                     else "unknown"
+                     end
+
+        BrainzLab::Reflex.add_breadcrumb(
+          "Stripe #{method.to_s.upcase} #{resource} failed: #{error.message}",
+          category: "payment",
+          level: :error,
+          data: {
+            method: method.to_s.upcase,
+            resource: resource,
+            error_type: error_type,
+            error: error.class.name
+          }
+        )
+
+        if BrainzLab.configuration.flux_effectively_enabled?
+          tags = { method: method.to_s.upcase, resource: resource, error_type: error_type }
+          BrainzLab::Flux.increment("stripe.errors", tags: tags)
+        end
+
+        # Capture with Reflex (but filter sensitive data)
+        if BrainzLab.configuration.reflex_effectively_enabled?
+          BrainzLab::Reflex.capture(error,
+            tags: { source: "stripe", resource: resource },
+            extra: { error_type: error_type }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/typhoeus.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module TyphoeusInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Typhoeus)
+
+          install_callbacks!
+
+          BrainzLab.debug_log("[Instrumentation] Typhoeus instrumentation installed")
+        end
+
+        private
+
+        def install_callbacks!
+          ::Typhoeus.on_complete do |response|
+            track_request(response)
+          end
+        end
+
+        def track_request(response)
+          request = response.request
+          return unless request
+
+          uri = URI.parse(request.base_url) rescue nil
+          return unless uri
+
+          host = uri.host
+          return if skip_host?(host)
+
+          method = (request.options[:method] || :get).to_s.upcase
+          path = uri.path.empty? ? "/" : uri.path
+          status = response.response_code
+          duration_ms = (response.total_time * 1000).round(2)
+
+          # Add breadcrumb
+          BrainzLab::Reflex.add_breadcrumb(
+            "HTTP #{method} #{host}#{path} -> #{status}",
+            category: "http",
+            level: response.success? ? :info : :error,
+            data: {
+              method: method,
+              host: host,
+              path: path,
+              status: status,
+              duration_ms: duration_ms
+            }
+          )
+
+          # Track with Flux
+          if BrainzLab.configuration.flux_effectively_enabled?
+            tags = { host: host, method: method, status: status.to_s }
+            BrainzLab::Flux.distribution("http.typhoeus.duration_ms", duration_ms, tags: tags)
+            BrainzLab::Flux.increment("http.typhoeus.requests", tags: tags)
+
+            unless response.success?
+              BrainzLab::Flux.increment("http.typhoeus.errors", tags: tags)
+            end
+
+            if response.timed_out?
+              BrainzLab::Flux.increment("http.typhoeus.timeouts", tags: { host: host })
+            end
+          end
+        end
+
+        def skip_host?(host)
+          return true unless host
+
+          ignore_hosts = BrainzLab.configuration.http_ignore_hosts || []
+          ignore_hosts.any? { |h| host.include?(h) }
+        end
+      end
+
+      # Hydra instrumentation for parallel requests
+      module HydraInstrumentation
+        def self.install!
+          return unless defined?(::Typhoeus::Hydra)
+
+          ::Typhoeus::Hydra.class_eval do
+            alias_method :original_run, :run
+
+            def run
+              started_at = Time.now
+              request_count = queued_requests.size
+
+              result = original_run
+
+              duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+              if BrainzLab.configuration.flux_effectively_enabled?
+                BrainzLab::Flux.distribution("http.typhoeus.hydra.duration_ms", duration_ms)
+                BrainzLab::Flux.distribution("http.typhoeus.hydra.request_count", request_count)
+              end
+
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation.rb

@@ -39,6 +39,22 @@ module BrainzLab
 
         # Grape API instrumentation
         install_grape! if config.instrument_grape
+
+        # Modern job queue instrumentation
+        install_solid_queue! if config.instrument_solid_queue
+        install_good_job! if config.instrument_good_job
+        install_resque! if config.instrument_resque
+
+        # Additional HTTP clients
+        install_excon! if config.instrument_excon
+        install_typhoeus! if config.instrument_typhoeus
+
+        # Caching
+        install_dalli! if config.instrument_dalli
+
+        # Cloud & Payment
+        install_aws! if config.instrument_aws
+        install_stripe! if config.instrument_stripe
       end
 
       def install_net_http!
@@ -121,6 +137,62 @@ module BrainzLab
         GrapeInstrumentation.install!
       end
 
+      def install_solid_queue!
+        return unless defined?(::SolidQueue)
+
+        require_relative "instrumentation/solid_queue"
+        SolidQueueInstrumentation.install!
+      end
+
+      def install_good_job!
+        return unless defined?(::GoodJob)
+
+        require_relative "instrumentation/good_job"
+        GoodJobInstrumentation.install!
+      end
+
+      def install_resque!
+        return unless defined?(::Resque)
+
+        require_relative "instrumentation/resque"
+        ResqueInstrumentation.install!
+      end
+
+      def install_excon!
+        return unless defined?(::Excon)
+
+        require_relative "instrumentation/excon"
+        ExconInstrumentation.install!
+      end
+
+      def install_typhoeus!
+        return unless defined?(::Typhoeus)
+
+        require_relative "instrumentation/typhoeus"
+        TyphoeusInstrumentation.install!
+      end
+
+      def install_dalli!
+        return unless defined?(::Dalli::Client)
+
+        require_relative "instrumentation/dalli"
+        DalliInstrumentation.install!
+      end
+
+      def install_aws!
+        return unless defined?(::Aws)
+
+        require_relative "instrumentation/aws"
+        AWSInstrumentation.install!
+      end
+
+      def install_stripe!
+        return unless defined?(::Stripe)
+
+        require_relative "instrumentation/stripe"
+        StripeInstrumentation.install!
+      end
+
       # Manual installation methods for lazy-loaded libraries
       def install_http!
         install_net_http!

data/lib/brainzlab/nerve/client.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module BrainzLab
+  module Nerve
+    class Client
+      def initialize(config)
+        @config = config
+        @base_url = config.nerve_url || "https://nerve.brainzlab.ai"
+      end
+
+      # Report a job execution
+      def report_job(job_class:, job_id:, queue:, status:, started_at:, ended_at:, **attributes)
+        response = request(
+          :post,
+          "/api/v1/jobs",
+          body: {
+            job_class: job_class,
+            job_id: job_id,
+            queue: queue,
+            status: status,
+            started_at: started_at.iso8601(3),
+            ended_at: ended_at.iso8601(3),
+            duration_ms: ((ended_at - started_at) * 1000).round(2),
+            **attributes
+          }
+        )
+
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+      rescue StandardError => e
+        log_error("report_job", e)
+        false
+      end
+
+      # Report a job failure
+      def report_failure(job_class:, job_id:, queue:, error_class:, error_message:, backtrace: nil, **attributes)
+        response = request(
+          :post,
+          "/api/v1/jobs/failures",
+          body: {
+            job_class: job_class,
+            job_id: job_id,
+            queue: queue,
+            error_class: error_class,
+            error_message: error_message,
+            backtrace: backtrace&.first(20),
+            failed_at: Time.now.utc.iso8601(3),
+            **attributes
+          }
+        )
+
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+      rescue StandardError => e
+        log_error("report_failure", e)
+        false
+      end
+
+      # Get job statistics
+      def stats(queue: nil, job_class: nil, period: "1h")
+        params = { period: period }
+        params[:queue] = queue if queue
+        params[:job_class] = job_class if job_class
+
+        response = request(:get, "/api/v1/stats", params: params)
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("stats", e)
+        nil
+      end
+
+      # List recent jobs
+      def list_jobs(queue: nil, status: nil, limit: 100)
+        params = { limit: limit }
+        params[:queue] = queue if queue
+        params[:status] = status if status
+
+        response = request(:get, "/api/v1/jobs", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:jobs] || []
+      rescue StandardError => e
+        log_error("list_jobs", e)
+        []
+      end
+
+      # List queues
+      def list_queues
+        response = request(:get, "/api/v1/queues")
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:queues] || []
+      rescue StandardError => e
+        log_error("list_queues", e)
+        []
+      end
+
+      # Get queue details
+      def get_queue(name)
+        response = request(:get, "/api/v1/queues/#{CGI.escape(name)}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_queue", e)
+        nil
+      end
+
+      # Retry a failed job
+      def retry_job(job_id)
+        response = request(:post, "/api/v1/jobs/#{job_id}/retry")
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError => e
+        log_error("retry_job", e)
+        false
+      end
+
+      # Delete a job
+      def delete_job(job_id)
+        response = request(:delete, "/api/v1/jobs/#{job_id}")
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPNoContent)
+      rescue StandardError => e
+        log_error("delete_job", e)
+        false
+      end
+
+      # Report queue metrics
+      def report_metrics(queue:, size:, latency_ms: nil, workers: nil)
+        response = request(
+          :post,
+          "/api/v1/metrics",
+          body: {
+            queue: queue,
+            size: size,
+            latency_ms: latency_ms,
+            workers: workers,
+            timestamp: Time.now.utc.iso8601(3)
+          }
+        )
+
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError => e
+        log_error("report_metrics", e)
+        false
+      end
+
+      def provision(project_id:, app_name:)
+        response = request(
+          :post,
+          "/api/v1/projects/provision",
+          body: { project_id: project_id, app_name: app_name },
+          use_service_key: true
+        )
+
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+      rescue StandardError => e
+        log_error("provision", e)
+        false
+      end
+
+      private
+
+      def request(method, path, headers: {}, body: nil, params: nil, use_service_key: false)
+        uri = URI.parse("#{@base_url}#{path}")
+
+        if params
+          uri.query = URI.encode_www_form(params)
+        end
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 5
+        http.read_timeout = 10
+
+        request = case method
+        when :get
+          Net::HTTP::Get.new(uri)
+        when :post
+          Net::HTTP::Post.new(uri)
+        when :put
+          Net::HTTP::Put.new(uri)
+        when :delete
+          Net::HTTP::Delete.new(uri)
+        end
+
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+
+        if use_service_key
+          request["X-Service-Key"] = @config.nerve_master_key || @config.secret_key
+        else
+          auth_key = @config.nerve_api_key || @config.secret_key
+          request["Authorization"] = "Bearer #{auth_key}" if auth_key
+        end
+
+        headers.each { |k, v| request[k] = v }
+        request.body = body.to_json if body
+
+        http.request(request)
+      end
+
+      def log_error(operation, error)
+        BrainzLab.debug_log("[Nerve::Client] #{operation} failed: #{error.message}")
+      end
+    end
+  end
+end

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["BRAINZLAB_PROJECT_ID"]
+      end
+    end
+  end
+end