fluyenta-ruby 0.1.14

data/lib/brainzlab/instrumentation/typhoeus.rb

@@ -0,0 +1,106 @@
+# 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 = begin
+            URI.parse(request.base_url)
+          rescue StandardError
+            nil
+          end
+          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
+          return unless 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)
+
+          BrainzLab::Flux.increment('http.typhoeus.errors', tags: tags) unless response.success?
+
+          return unless response.timed_out?
+
+          BrainzLab::Flux.increment('http.typhoeus.timeouts', tags: { host: host })
+        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

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    class << self
+      def install!
+        config = BrainzLab.configuration
+
+        # Skip all instrumentation if SDK is disabled
+        unless config.enabled?
+          BrainzLab.debug_log('[Instrumentation] SDK disabled via BRAINZLAB_SDK_ENABLED=false, skipping all instrumentation')
+          return
+        end
+
+        # Skip Rails-specific instrumentation if brainzlab-rails gem is handling it
+        # This prevents double-tracking of events
+        if config.rails_instrumentation_handled_externally
+          BrainzLab.debug_log('[Instrumentation] Rails instrumentation handled by brainzlab-rails gem, skipping SDK instrumentation')
+          install_non_rails_instrumentation!(config)
+          return
+        end
+
+        # HTTP client instrumentation
+        if config.instrument_http
+          install_net_http!
+          install_faraday!
+          install_httparty!
+        end
+
+        # Database instrumentation (breadcrumbs for Reflex)
+        install_active_record! if config.instrument_active_record
+
+        # Redis instrumentation
+        install_redis! if config.instrument_redis
+
+        # Background job instrumentation
+        install_sidekiq! if config.instrument_sidekiq
+
+        # GraphQL instrumentation
+        install_graphql! if config.instrument_graphql
+
+        # MongoDB instrumentation
+        install_mongodb! if config.instrument_mongodb
+
+        # Elasticsearch instrumentation
+        install_elasticsearch! if config.instrument_elasticsearch
+
+        # Rails MVC instrumentation
+        install_action_controller! if config.instrument_action_controller
+        install_action_view! if config.instrument_action_view
+        install_action_mailer! if config.instrument_action_mailer
+
+        # ActiveJob instrumentation (covers all job backends)
+        install_active_job! if config.instrument_active_job
+
+        # ActiveSupport::Cache instrumentation
+        install_active_support_cache! if config.instrument_active_support_cache
+
+        # Delayed::Job instrumentation
+        install_delayed_job! if config.instrument_delayed_job
+
+        # 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
+
+        # File storage
+        install_active_storage! if config.instrument_active_storage
+
+        # WebSocket
+        install_action_cable! if config.instrument_action_cable
+
+        # Rails framework events
+        install_action_dispatch! if config.instrument_action_dispatch
+        install_rails_deprecation! if config.instrument_rails_deprecation
+        install_action_mailbox! if config.instrument_action_mailbox
+        install_railties! if config.instrument_railties
+      end
+
+      def install_net_http!
+        require_relative 'instrumentation/net_http'
+        NetHttp.install!
+      end
+
+      def install_faraday!
+        return unless defined?(::Faraday)
+
+        require_relative 'instrumentation/faraday'
+        FaradayMiddleware.install!
+      end
+
+      def install_httparty!
+        return unless defined?(::HTTParty)
+
+        require_relative 'instrumentation/httparty'
+        HTTPartyInstrumentation.install!
+      end
+
+      def install_active_record!
+        require_relative 'instrumentation/active_record'
+        ActiveRecord.install!
+      end
+
+      def install_redis!
+        return unless defined?(::Redis)
+
+        require_relative 'instrumentation/redis'
+        RedisInstrumentation.install!
+      end
+
+      def install_sidekiq!
+        return unless defined?(::Sidekiq)
+
+        require_relative 'instrumentation/sidekiq'
+        SidekiqInstrumentation.install!
+      end
+
+      def install_graphql!
+        return unless defined?(::GraphQL)
+
+        require_relative 'instrumentation/graphql'
+        GraphQLInstrumentation.install!
+      end
+
+      def install_mongodb!
+        return unless defined?(::Mongo) || defined?(::Mongoid)
+
+        require_relative 'instrumentation/mongodb'
+        MongoDBInstrumentation.install!
+      end
+
+      def install_elasticsearch!
+        return unless defined?(::Elasticsearch) || defined?(::OpenSearch)
+
+        require_relative 'instrumentation/elasticsearch'
+        ElasticsearchInstrumentation.install!
+      end
+
+      def install_action_controller!
+        return unless defined?(::ActionController)
+
+        require_relative 'instrumentation/action_controller'
+        ActionController.install!
+      end
+
+      def install_action_view!
+        return unless defined?(::ActionView)
+
+        require_relative 'instrumentation/action_view'
+        ActionView.install!
+      end
+
+      def install_action_mailer!
+        return unless defined?(::ActionMailer)
+
+        require_relative 'instrumentation/action_mailer'
+        ActionMailerInstrumentation.install!
+      end
+
+      def install_active_job!
+        return unless defined?(::ActiveJob)
+
+        require_relative 'instrumentation/active_job'
+        ActiveJob.install!
+      end
+
+      def install_active_support_cache!
+        return unless defined?(::ActiveSupport::Cache)
+
+        require_relative 'instrumentation/active_support_cache'
+        ActiveSupportCache.install!
+      end
+
+      def install_delayed_job!
+        return unless defined?(::Delayed::Job) || defined?(::Delayed::Backend)
+
+        require_relative 'instrumentation/delayed_job'
+        DelayedJobInstrumentation.install!
+      end
+
+      def install_grape!
+        return unless defined?(::Grape::API)
+
+        require_relative 'instrumentation/grape'
+        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
+
+      def install_active_storage!
+        return unless defined?(::ActiveStorage)
+
+        require_relative 'instrumentation/active_storage'
+        ActiveStorage.install!
+      end
+
+      def install_action_cable!
+        return unless defined?(::ActionCable)
+
+        require_relative 'instrumentation/action_cable'
+        ActionCable.install!
+      end
+
+      def install_action_dispatch!
+        return unless defined?(::ActionDispatch)
+
+        require_relative 'instrumentation/action_dispatch'
+        ActionDispatch.install!
+      end
+
+      def install_rails_deprecation!
+        return unless defined?(::Rails)
+
+        require_relative 'instrumentation/rails_deprecation'
+        RailsDeprecation.install!
+      end
+
+      def install_action_mailbox!
+        return unless defined?(::ActionMailbox)
+
+        require_relative 'instrumentation/action_mailbox'
+        ActionMailbox.install!
+      end
+
+      def install_railties!
+        return unless defined?(::Rails)
+
+        require_relative 'instrumentation/railties'
+        Railties.install!
+      end
+
+      # Manual installation methods for lazy-loaded libraries
+      def install_http!
+        install_net_http!
+        install_faraday!
+        install_httparty!
+      end
+
+      private
+
+      # Install only non-Rails-specific instrumentation
+      # Used when brainzlab-rails gem handles Rails events via ActiveSupport::Notifications
+      def install_non_rails_instrumentation!(config)
+        # HTTP client instrumentation (not Rails-specific)
+        if config.instrument_http
+          install_net_http!
+          install_faraday!
+          install_httparty!
+        end
+
+        # Redis instrumentation (not Rails-specific)
+        install_redis! if config.instrument_redis
+
+        # Sidekiq instrumentation (not Rails-specific, has its own hooks)
+        install_sidekiq! if config.instrument_sidekiq
+
+        # GraphQL instrumentation (not Rails-specific)
+        install_graphql! if config.instrument_graphql
+
+        # MongoDB instrumentation (not Rails-specific)
+        install_mongodb! if config.instrument_mongodb
+
+        # Elasticsearch instrumentation (not Rails-specific)
+        install_elasticsearch! if config.instrument_elasticsearch
+
+        # Delayed::Job instrumentation (not Rails-specific, has its own hooks)
+        install_delayed_job! if config.instrument_delayed_job
+
+        # Grape API instrumentation (not Rails-specific)
+        install_grape! if config.instrument_grape
+
+        # Modern job queue instrumentation (have their own hooks)
+        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 (not Rails-specific)
+        install_excon! if config.instrument_excon
+        install_typhoeus! if config.instrument_typhoeus
+
+        # Dalli/Memcached (not Rails-specific, has its own hooks)
+        install_dalli! if config.instrument_dalli
+
+        # Cloud & Payment (not Rails-specific)
+        install_aws! if config.instrument_aws
+        install_stripe! if config.instrument_stripe
+
+        BrainzLab.debug_log('[Instrumentation] Non-Rails instrumentation installed (HTTP, Redis, Sidekiq, GraphQL, etc.)')
+      end
+    end
+  end
+end

data/lib/brainzlab/nerve/client.rb

@@ -0,0 +1,235 @@
+# 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}")
+
+        uri.query = URI.encode_www_form(params) if params
+
+        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)
+        structured_error = ErrorHandler.wrap(error, service: 'Nerve', operation: operation)
+        BrainzLab.debug_log("[Nerve::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Nerve', 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)
+
+        structured_error = ErrorHandler.from_response(response, service: 'Nerve', operation: operation)
+        BrainzLab.debug_log("[Nerve::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Nerve', operation: operation })
+        end
+
+        structured_error
+      end
+    end
+  end
+end