activerabbit-ai 0.1.0

data/examples/standalone_usage.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+# Example standalone usage of ActiveRabbit::Client (non-Rails applications)
+
+require 'active_rabbit/client'
+
+# Basic configuration
+ActiveRabbit::Client.configure do |config|
+  config.api_key = 'your-api-key-here'
+  config.project_id = 'your-project-id'
+  config.api_url = 'https://api.activerabbit.com'
+  config.environment = ENV.fetch('RACK_ENV', 'development')
+
+  # Standalone applications might want different settings
+  config.batch_size = 20
+  config.flush_interval = 10
+  config.enable_performance_monitoring = true
+  config.enable_pii_scrubbing = true
+end
+
+# Example: Sinatra application
+require 'sinatra'
+
+class MyApp < Sinatra::Base
+  configure do
+    # Add exception handling middleware
+    use Rack::CommonLogger
+
+    # Custom middleware for ActiveRabbit context
+    use Class.new do
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        # Set request context
+        Thread.current[:active_rabbit_request_context] = {
+          method: request.request_method,
+          path: request.path_info,
+          query_string: request.query_string,
+          user_agent: request.user_agent,
+          ip_address: request.ip
+        }
+
+        begin
+          @app.call(env)
+        rescue Exception => e
+          # Track unhandled exceptions
+          ActiveRabbit::Client.track_exception(
+            e,
+            context: {
+              request: {
+                method: request.request_method,
+                path: request.path_info,
+                params: request.params
+              }
+            }
+          )
+          raise
+        ensure
+          Thread.current[:active_rabbit_request_context] = nil
+        end
+      end
+    end
+  end
+
+  get '/api/users/:id' do
+    # Track API endpoint usage
+    ActiveRabbit::Client.track_event(
+      'api_endpoint_accessed',
+      {
+        endpoint: '/api/users/:id',
+        user_id: params[:id]
+      }
+    )
+
+    # Performance monitoring
+    user_data = ActiveRabbit::Client.performance_monitor.measure('user_lookup') do
+      # Simulate database lookup
+      sleep(0.1)
+      { id: params[:id], name: "User #{params[:id]}" }
+    end
+
+    content_type :json
+    user_data.to_json
+  end
+
+  post '/api/process' do
+    begin
+      # Process some data
+      result = process_data(params)
+
+      ActiveRabbit::Client.track_event(
+        'data_processed',
+        {
+          records_processed: result[:count],
+          processing_time_ms: result[:duration]
+        }
+      )
+
+      { status: 'success', result: result }.to_json
+    rescue ProcessingError => e
+      ActiveRabbit::Client.track_exception(
+        e,
+        context: {
+          input_data: params,
+          processing_stage: e.stage
+        },
+        tags: {
+          component: 'data_processor',
+          severity: 'medium'
+        }
+      )
+
+      status 422
+      { error: 'Processing failed' }.to_json
+    end
+  end
+
+  private
+
+  def process_data(data)
+    start_time = Time.current
+
+    # Simulate processing
+    count = data['items']&.length || 0
+    sleep(count * 0.01) # Simulate work
+
+    {
+      count: count,
+      duration: ((Time.current - start_time) * 1000).round(2)
+    }
+  end
+end
+
+# Example: Background worker script
+class BackgroundWorker
+  def initialize
+    # Configure ActiveRabbit for background processes
+    ActiveRabbit::Client.configure do |config|
+      config.api_key = ENV['active_rabbit_API_KEY']
+      config.project_id = ENV['active_rabbit_PROJECT_ID']
+      config.environment = ENV.fetch('ENVIRONMENT', 'development')
+      config.server_name = "worker-#{Socket.gethostname}"
+    end
+  end
+
+  def run
+    puts "Starting background worker..."
+
+    ActiveRabbit::Client.track_event('worker_started', {
+      hostname: Socket.gethostname,
+      pid: Process.pid
+    })
+
+    loop do
+      begin
+        job = fetch_next_job
+        break unless job
+
+        process_job(job)
+      rescue => e
+        ActiveRabbit::Client.track_exception(
+          e,
+          context: { component: 'background_worker' },
+          tags: { severity: 'high' }
+        )
+
+        sleep 5 # Wait before retrying
+      end
+    end
+
+    ActiveRabbit::Client.track_event('worker_stopped')
+    ActiveRabbit::Client.shutdown
+  end
+
+  private
+
+  def fetch_next_job
+    # Simulate job fetching
+    return nil if rand > 0.8 # 20% chance of getting a job
+
+    {
+      id: SecureRandom.uuid,
+      type: ['email', 'report', 'cleanup'].sample,
+      data: { user_id: rand(1000) }
+    }
+  end
+
+  def process_job(job)
+    transaction_id = ActiveRabbit::Client.performance_monitor.start_transaction(
+      "job_#{job[:type]}",
+      metadata: { job_id: job[:id] }
+    )
+
+    begin
+      # Simulate job processing
+      case job[:type]
+      when 'email'
+        send_email(job[:data])
+      when 'report'
+        generate_report(job[:data])
+      when 'cleanup'
+        cleanup_data(job[:data])
+      end
+
+      ActiveRabbit::Client.track_event(
+        'job_completed',
+        {
+          job_id: job[:id],
+          job_type: job[:type]
+        }
+      )
+    rescue => e
+      ActiveRabbit::Client.track_exception(
+        e,
+        context: {
+          job: job,
+          component: 'job_processor'
+        }
+      )
+      raise
+    ensure
+      ActiveRabbit::Client.performance_monitor.finish_transaction(
+        transaction_id,
+        additional_metadata: { status: 'completed' }
+      )
+    end
+  end
+
+  def send_email(data)
+    sleep(0.2) # Simulate email sending
+  end
+
+  def generate_report(data)
+    sleep(0.5) # Simulate report generation
+  end
+
+  def cleanup_data(data)
+    sleep(0.1) # Simulate cleanup
+  end
+end
+
+# Example: Rake task integration
+# lib/tasks/data_migration.rake
+namespace :data do
+  desc "Migrate user data"
+  task migrate_users: :environment do
+    ActiveRabbit::Client.configure do |config|
+      config.api_key = ENV['active_rabbit_API_KEY']
+      config.project_id = ENV['active_rabbit_PROJECT_ID']
+      config.environment = 'migration'
+    end
+
+    start_time = Time.current
+    processed_count = 0
+    error_count = 0
+
+    ActiveRabbit::Client.track_event('migration_started', {
+      task: 'migrate_users',
+      started_at: start_time
+    })
+
+    begin
+      User.find_each do |user|
+        begin
+          migrate_user(user)
+          processed_count += 1
+        rescue => e
+          error_count += 1
+          ActiveRabbit::Client.track_exception(
+            e,
+            context: {
+              user_id: user.id,
+              migration_task: 'migrate_users'
+            }
+          )
+        end
+      end
+
+      duration = Time.current - start_time
+
+      ActiveRabbit::Client.track_event('migration_completed', {
+        task: 'migrate_users',
+        duration_seconds: duration.round(2),
+        processed_count: processed_count,
+        error_count: error_count
+      })
+
+      puts "Migration completed: #{processed_count} users processed, #{error_count} errors"
+    ensure
+      ActiveRabbit::Client.shutdown
+    end
+  end
+end
+
+# Usage examples:
+
+# 1. Run the Sinatra app
+# ruby standalone_usage.rb
+
+# 2. Run the background worker
+# worker = BackgroundWorker.new
+# worker.run
+
+# 3. Run the rake task
+# rake data:migrate_users

data/lib/active_rabbit/client/configuration.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "socket"
+require "logger"
+
+module ActiveRabbit
+  module Client
+    class Configuration
+      attr_accessor :api_key, :api_url, :project_id, :environment
+      attr_accessor :timeout, :open_timeout, :retry_count, :retry_delay
+      attr_accessor :batch_size, :flush_interval, :queue_size
+      attr_accessor :enable_performance_monitoring, :enable_n_plus_one_detection
+      attr_accessor :enable_pii_scrubbing, :pii_fields
+      attr_accessor :ignored_exceptions, :ignored_user_agents
+      attr_accessor :release, :server_name, :logger
+      attr_accessor :before_send_event, :before_send_exception
+
+      def initialize
+        @api_url = ENV.fetch("active_rabbit_API_URL", "https://api.activerabbit.com")
+        @api_key = ENV["active_rabbit_API_KEY"]
+        @project_id = ENV["active_rabbit_PROJECT_ID"]
+        @environment = ENV.fetch("active_rabbit_ENVIRONMENT", detect_environment)
+
+        # HTTP settings
+        @timeout = 30
+        @open_timeout = 10
+        @retry_count = 3
+        @retry_delay = 1
+
+        # Batching settings
+        @batch_size = 100
+        @flush_interval = 30 # seconds
+        @queue_size = 1000
+
+        # Feature flags
+        @enable_performance_monitoring = true
+        @enable_n_plus_one_detection = true
+        @enable_pii_scrubbing = true
+
+        # PII scrubbing
+        @pii_fields = %w[
+          password password_confirmation token secret key
+          credit_card ssn social_security_number phone email
+          first_name last_name name address city state zip
+        ]
+
+        # Filtering
+        @ignored_exceptions = %w[
+          ActiveRecord::RecordNotFound
+          ActionController::RoutingError
+          ActionController::InvalidAuthenticityToken
+          CGI::Session::CookieStore::TamperedWithCookie
+        ]
+
+        @ignored_user_agents = [
+          /Googlebot/i,
+          /bingbot/i,
+          /facebookexternalhit/i,
+          /Twitterbot/i
+        ]
+
+        # Metadata
+        @release = detect_release
+        @server_name = detect_server_name
+        @logger = detect_logger
+
+        # Callbacks
+        @before_send_event = nil
+        @before_send_exception = nil
+      end
+
+      def valid?
+        return false unless api_key
+        return false if api_key.empty?
+        return false unless api_url
+        return false if api_url.empty?
+        true
+      end
+
+      def api_endpoint(path)
+        "#{api_url.chomp('/')}/#{path.to_s.sub(/^\//, '')}"
+      end
+
+      def should_ignore_exception?(exception)
+        return false unless exception
+
+        ignored_exceptions.any? do |ignored|
+          case ignored
+          when String
+            exception.class.name == ignored
+          when Class
+            exception.is_a?(ignored)
+          when Regexp
+            exception.class.name =~ ignored
+          else
+            false
+          end
+        end
+      end
+
+      def should_ignore_user_agent?(user_agent)
+        return false unless user_agent
+
+        ignored_user_agents.any? do |pattern|
+          case pattern
+          when String
+            user_agent.include?(pattern)
+          when Regexp
+            user_agent =~ pattern
+          else
+            false
+          end
+        end
+      end
+
+      private
+
+      def detect_environment
+        return Rails.env if defined?(Rails) && Rails.respond_to?(:env)
+        return Sinatra::Base.environment.to_s if defined?(Sinatra)
+
+        ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
+      end
+
+      def detect_release
+        # Try to detect from common CI/deployment environment variables
+        ENV["HEROKU_SLUG_COMMIT"] ||
+          ENV["GITHUB_SHA"] ||
+          ENV["GITLAB_COMMIT_SHA"] ||
+          ENV["CIRCLE_SHA1"] ||
+          ENV["TRAVIS_COMMIT"] ||
+          ENV["BUILD_VCS_NUMBER"] ||
+          detect_git_sha
+      end
+
+      def detect_git_sha
+        return unless File.directory?(".git")
+
+        `git rev-parse HEAD 2>/dev/null`.chomp
+      rescue
+        nil
+      end
+
+      def detect_server_name
+        ENV["DYNO"] || # Heroku
+          ENV["HOSTNAME"] || # Docker
+          ENV["SERVER_NAME"] ||
+          Socket.gethostname
+      rescue
+        "unknown"
+      end
+
+      def detect_logger
+        return Rails.logger if defined?(Rails) && Rails.respond_to?(:logger)
+
+        Logger.new($stdout).tap do |logger|
+          logger.level = Logger::INFO
+        end
+      end
+    end
+  end
+end

data/lib/active_rabbit/client/event_processor.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module ActiveRabbit
+  module Client
+    class EventProcessor
+      attr_reader :configuration, :http_client
+
+      def initialize(configuration, http_client)
+        @configuration = configuration
+        @http_client = http_client
+        @event_queue = Concurrent::Array.new
+        @processor_thread = nil
+        @shutdown = false
+      end
+
+      def track_event(name:, properties: {}, user_id: nil, timestamp: nil)
+        return if @shutdown
+
+        event_data = build_event_data(
+          name: name,
+          properties: properties,
+          user_id: user_id,
+          timestamp: timestamp
+        )
+
+        # Apply before_send callback if configured
+        if configuration.before_send_event
+          event_data = configuration.before_send_event.call(event_data)
+          return unless event_data # Callback can filter out events by returning nil
+        end
+
+        @event_queue << event_data
+        ensure_processor_running
+      end
+
+      def flush
+        return if @event_queue.empty?
+
+        events = @event_queue.shift(@event_queue.length)
+        return if events.empty?
+
+        events.each_slice(configuration.batch_size) do |batch|
+          http_client.post_batch(batch)
+        end
+      end
+
+      def shutdown
+        @shutdown = true
+        @processor_thread&.kill
+        flush
+      end
+
+      private
+
+      def build_event_data(name:, properties:, user_id:, timestamp:)
+        data = {
+          name: name.to_s,
+          properties: scrub_pii(properties || {}),
+          timestamp: (timestamp || Time.now).iso8601(3),
+          environment: configuration.environment,
+          release: configuration.release,
+          server_name: configuration.server_name
+        }
+
+        data[:user_id] = user_id if user_id
+        data[:project_id] = configuration.project_id if configuration.project_id
+
+        # Add context information
+        data[:context] = build_context
+
+        data
+      end
+
+      def build_context
+        context = {}
+
+        # Runtime information
+        context[:runtime] = {
+          name: "ruby",
+          version: RUBY_VERSION,
+          platform: RUBY_PLATFORM
+        }
+
+        # Framework information
+        if defined?(Rails)
+          context[:framework] = {
+            name: "rails",
+            version: Rails.version
+          }
+        elsif defined?(Sinatra)
+          context[:framework] = {
+            name: "sinatra",
+            version: Sinatra::VERSION
+          }
+        end
+
+        # Request information (if available)
+        if defined?(Thread) && Thread.current[:active_rabbit_request_context]
+          context[:request] = Thread.current[:active_rabbit_request_context]
+        end
+
+        context
+      end
+
+      def scrub_pii(data)
+        return data unless configuration.enable_pii_scrubbing
+
+        PiiScrubber.new(configuration).scrub(data)
+      end
+
+      def ensure_processor_running
+        return if @processor_thread&.alive?
+
+        @processor_thread = Thread.new do
+          loop do
+            break if @shutdown
+
+            begin
+              sleep(configuration.flush_interval)
+              flush unless @event_queue.empty?
+            rescue => e
+              configuration.logger&.error("[ActiveRabbit] Event processor error: #{e.message}")
+            end
+          end
+        end
+      end
+    end
+  end
+end