sciosano 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 73fb2925974df5b63181c7c779e858925c9fb9c3436ff52552c5c0b0f1728cc9
+  data.tar.gz: 44e45cdcd6ee30964525ca43b548a9ecadad625d8f87a208011bebd39ad5dc51
+SHA512:
+  metadata.gz: 4458052c4fe5918de076b99fabfb99d20077dd8671ee18f8417581eb2449f1ca39c485400f48e35790842f40c279a791651d6c44a702ac32a17b34f5cf70ddaf
+  data.tar.gz: 6d76b282a9910a5a74743fff810aa53312163a167fb9acfef119856943c052048f21a0a6025005665d9f74844ab2a4fc828c24fbd0d3f715228b4cf3532a8185

data/lib/sciosano/breadcrumb.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Sciosano
+  # Breadcrumb represents a single user action or event
+  class Breadcrumb
+    TYPES = %i[default http navigation click console custom].freeze
+
+    attr_reader :type, :category, :message, :data, :timestamp
+
+    def initialize(type: :default, category:, message:, data: {}, timestamp: nil)
+      @type = TYPES.include?(type) ? type : :default
+      @category = category.to_s
+      @message = message.to_s
+      @data = data
+      @timestamp = timestamp || Time.now.utc.iso8601(3)
+    end
+
+    # Convert to hash for API
+    #
+    # @return [Hash]
+    def to_h
+      {
+        type: type,
+        category: category,
+        message: message,
+        data: data,
+        timestamp: timestamp
+      }
+    end
+
+    # Create HTTP request breadcrumb
+    #
+    # @param method [String] HTTP method
+    # @param url [String] Request URL
+    # @param status_code [Integer] Response status
+    # @param duration [Float] Request duration in ms
+    # @return [Breadcrumb]
+    def self.http(method:, url:, status_code: nil, duration: nil)
+      new(
+        type: :http,
+        category: "http",
+        message: "#{method.upcase} #{url}",
+        data: {
+          method: method.upcase,
+          url: url,
+          status_code: status_code,
+          duration: duration
+        }.compact
+      )
+    end
+
+    # Create navigation breadcrumb
+    #
+    # @param from [String] Previous URL/path
+    # @param to [String] New URL/path
+    # @return [Breadcrumb]
+    def self.navigation(from:, to:)
+      new(
+        type: :navigation,
+        category: "navigation",
+        message: "Navigated to #{to}",
+        data: { from: from, to: to }
+      )
+    end
+
+    # Create console/log breadcrumb
+    #
+    # @param level [Symbol] Log level
+    # @param message [String] Log message
+    # @return [Breadcrumb]
+    def self.console(level:, message:)
+      new(
+        type: :console,
+        category: "console",
+        message: message.to_s[0..500],
+        data: { level: level }
+      )
+    end
+
+    # Create ActiveRecord query breadcrumb
+    #
+    # @param sql [String] SQL query
+    # @param name [String] Query name
+    # @param duration [Float] Query duration in ms
+    # @return [Breadcrumb]
+    def self.query(sql:, name: nil, duration: nil)
+      # Truncate long queries
+      truncated_sql = sql.to_s[0..500]
+      truncated_sql += "..." if sql.to_s.length > 500
+
+      new(
+        type: :default,
+        category: "query",
+        message: name || "SQL Query",
+        data: {
+          sql: truncated_sql,
+          duration: duration
+        }.compact
+      )
+    end
+
+    # Create Sidekiq job breadcrumb
+    #
+    # @param job_class [String] Job class name
+    # @param job_id [String] Job ID
+    # @param queue [String] Queue name
+    # @return [Breadcrumb]
+    def self.sidekiq_job(job_class:, job_id:, queue:)
+      new(
+        type: :default,
+        category: "job",
+        message: "Processing #{job_class}",
+        data: {
+          job_class: job_class,
+          job_id: job_id,
+          queue: queue
+        }
+      )
+    end
+  end
+end

data/lib/sciosano/client.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Sciosano
+  # Main client for sending reports to sciosano API
+  class Client
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+      @configuration.validate!
+      @context = Context.new
+      @breadcrumbs = Concurrent::Array.new
+      @executor = Concurrent::ThreadPoolExecutor.new(
+        min_threads: 1,
+        max_threads: 5,
+        max_queue: 100,
+        fallback_policy: :caller_runs # Don't silently discard - run in caller thread if queue full
+      )
+
+      log("sciosano initialized with endpoint: #{configuration.endpoint}")
+    end
+
+    # Capture an exception
+    #
+    # @param exception [Exception]
+    # @param context [Hash]
+    # @return [String, nil] Report ID
+    def capture_exception(exception, context = {})
+      return nil unless should_capture?(exception)
+
+      report = Report.build_from_exception(
+        exception,
+        context: @context.merge(context),
+        breadcrumbs: @breadcrumbs.to_a,
+        configuration: configuration
+      )
+
+      send_report(report)
+    end
+
+    # Capture a message
+    #
+    # @param message [String]
+    # @param level [Symbol]
+    # @param context [Hash]
+    # @return [String, nil] Report ID
+    def capture_message(message, level: :info, context: {})
+      report = Report.build_from_message(
+        message,
+        level: level,
+        context: @context.merge(context),
+        breadcrumbs: @breadcrumbs.to_a,
+        configuration: configuration
+      )
+
+      send_report(report)
+    end
+
+    # Add a breadcrumb
+    #
+    # @param breadcrumb [Breadcrumb]
+    def add_breadcrumb(breadcrumb)
+      @breadcrumbs << breadcrumb
+
+      # Keep only max_breadcrumbs
+      while @breadcrumbs.size > configuration.max_breadcrumbs
+        @breadcrumbs.shift
+      end
+    end
+
+    # Set user context
+    def set_user(id: nil, email: nil, name: nil, **extra)
+      @context.user = { id: id, email: email, name: name, **extra }.compact
+    end
+
+    # Clear user context
+    def clear_user
+      @context.user = nil
+    end
+
+    # Set extra context
+    def set_extra(key, value)
+      @context.extra[key.to_s] = value
+    end
+
+    # Set tags
+    def set_tags(tags)
+      @context.tags.merge!(tags.transform_keys(&:to_s))
+    end
+
+    # Execute block with additional context
+    def with_context(context = {})
+      old_context = @context.dup
+      @context.merge!(context)
+      yield
+    ensure
+      @context = old_context
+    end
+
+    # Get current breadcrumbs
+    def breadcrumbs
+      @breadcrumbs.to_a
+    end
+
+    # Clear breadcrumbs
+    def clear_breadcrumbs
+      @breadcrumbs.clear
+    end
+
+    private
+
+    def should_capture?(exception)
+      # Check sample rate
+      return false if rand > configuration.sample_rate
+
+      # Check ignore patterns
+      exception_class = exception.class.name
+      exception_message = exception.message
+
+      configuration.ignore_patterns.none? do |pattern|
+        case pattern
+        when Class
+          exception.is_a?(pattern)
+        when String
+          exception_class == pattern || exception_message.include?(pattern)
+        when Regexp
+          pattern.match?(exception_class) || pattern.match?(exception_message)
+        else
+          false
+        end
+      end
+    end
+
+    def send_report(report)
+      # Apply before_send callback
+      if configuration.before_send
+        report = configuration.before_send.call(report)
+        return nil if report.nil?
+      end
+
+      if configuration.async
+        send_async(report)
+      else
+        send_sync(report)
+      end
+    end
+
+    def send_async(report)
+      @executor.post do
+        send_sync(report)
+      end
+
+      # Return a placeholder ID for async sends
+      report.id
+    end
+
+    def send_sync(report, retries: 3)
+      attempts = 0
+
+      begin
+        attempts += 1
+        response = connection.post("/reports") do |req|
+          req.headers["x-sciosano-api-key"] = configuration.api_key
+          req.headers["Content-Type"] = "application/json"
+          req.body = report.to_json
+        end
+
+        if response.success?
+          data = JSON.parse(response.body)
+          report_id = data["id"] || data["reportId"]
+          log("Report sent successfully: #{report_id}")
+          report_id
+        else
+          log("Failed to send report: #{response.status} #{response.body}", level: :error)
+          nil
+        end
+      rescue Faraday::TimeoutError, Faraday::ConnectionFailed => e
+        if attempts < retries
+          sleep_time = 2**attempts # Exponential backoff: 2, 4, 8 seconds
+          log("Network error (attempt #{attempts}/#{retries}), retrying in #{sleep_time}s: #{e.message}", level: :warn)
+          sleep(sleep_time)
+          retry
+        end
+        log("Failed after #{retries} attempts: #{e.message}", level: :error)
+        nil
+      rescue Faraday::Error => e
+        log("Network error sending report: #{e.message}", level: :error)
+        nil
+      end
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: configuration.endpoint) do |f|
+        f.options.timeout = configuration.timeout
+        f.options.open_timeout = configuration.timeout
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def log(message, level: :info)
+      formatted = "[Sciosano] #{message}"
+
+      # Always log errors and warnings (important for production visibility)
+      # Only gate debug/info messages behind configuration.debug
+      case level
+      when :error
+        if defined?(Rails.logger) && Rails.logger
+          Rails.logger.error(formatted)
+        else
+          warn "#{formatted}"
+        end
+      when :warn
+        if defined?(Rails.logger) && Rails.logger
+          Rails.logger.warn(formatted)
+        else
+          warn "#{formatted}"
+        end
+      else
+        # Debug/info messages are gated
+        return unless configuration.debug
+
+        if defined?(Rails.logger) && Rails.logger
+          Rails.logger.info(formatted)
+        else
+          puts formatted
+        end
+      end
+    end
+  end
+end

data/lib/sciosano/configuration.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Sciosano
+  # Configuration for sciosano client
+  class Configuration
+    # API key for authentication (required)
+    # @return [String]
+    attr_accessor :api_key
+
+    # Application ID (optional, extracted from API key if not provided)
+    # @return [String, nil]
+    attr_accessor :app_id
+
+    # API endpoint URL
+    # @return [String]
+    attr_accessor :endpoint
+
+    # Environment name (development, staging, production)
+    # @return [String]
+    attr_accessor :environment
+
+    # Release/version identifier
+    # @return [String, nil]
+    attr_accessor :release
+
+    # Enable debug logging
+    # @return [Boolean]
+    attr_accessor :debug
+
+    # Sample rate for error capture (0.0 to 1.0)
+    # @return [Float]
+    attr_accessor :sample_rate
+
+    # Maximum breadcrumbs to keep
+    # @return [Integer]
+    attr_accessor :max_breadcrumbs
+
+    # Timeout for API requests in seconds
+    # @return [Integer]
+    attr_accessor :timeout
+
+    # Enable async sending (non-blocking)
+    # @return [Boolean]
+    attr_accessor :async
+
+    # Callback before sending report
+    # @return [Proc, nil]
+    attr_accessor :before_send
+
+    # Patterns to ignore (exception classes or message patterns)
+    # @return [Array<Class, String, Regexp>]
+    attr_accessor :ignore_patterns
+
+    # Enable Rails integration
+    # @return [Boolean]
+    attr_accessor :rails_enabled
+
+    # Enable Sidekiq integration
+    # @return [Boolean]
+    attr_accessor :sidekiq_enabled
+
+    # Enable ActiveJob integration
+    # @return [Boolean]
+    attr_accessor :active_job_enabled
+
+    # Parameters to filter from reports
+    # @return [Array<String, Symbol, Regexp>]
+    attr_accessor :filter_parameters
+
+    def initialize
+      @api_key = nil
+      @app_id = nil
+      @endpoint = "https://api.sciosano.com"
+      @environment = ENV.fetch("RAILS_ENV", ENV.fetch("RACK_ENV", "development"))
+      @release = nil
+      @debug = false
+      @sample_rate = 1.0
+      @max_breadcrumbs = 100
+      @timeout = 5
+      @async = true
+      @before_send = nil
+      @ignore_patterns = default_ignore_patterns
+      @rails_enabled = true
+      @sidekiq_enabled = true
+      @active_job_enabled = true
+      @filter_parameters = default_filter_parameters
+    end
+
+    # Validate configuration
+    #
+    # @raise [ConfigurationError] if configuration is invalid
+    def validate!
+      raise ConfigurationError, "API key is required" if api_key.nil? || api_key.empty?
+      raise ConfigurationError, "Invalid API key format" unless api_key.match?(/^sciosano_\w+_[a-zA-Z0-9]+$/)
+      raise ConfigurationError, "Sample rate must be between 0.0 and 1.0" unless (0.0..1.0).cover?(sample_rate)
+    end
+
+    # Check if configuration is valid
+    #
+    # @return [Boolean]
+    def valid?
+      validate!
+      true
+    rescue ConfigurationError
+      false
+    end
+
+    # Check if environment is development
+    #
+    # @return [Boolean]
+    def development?
+      environment == "development"
+    end
+
+    # Check if environment is production
+    #
+    # @return [Boolean]
+    def production?
+      environment == "production"
+    end
+
+    private
+
+    def default_ignore_patterns
+      [
+        # Common non-errors
+        "ActionController::RoutingError",
+        "ActionController::InvalidAuthenticityToken",
+        "ActionController::UnknownFormat",
+        "ActiveRecord::RecordNotFound",
+        # Signal exceptions
+        "SignalException",
+        "SystemExit",
+        # Bot/crawler errors
+        /crawl|bot|spider/i
+      ]
+    end
+
+    def default_filter_parameters
+      %i[
+        password
+        password_confirmation
+        secret
+        token
+        api_key
+        apikey
+        access_token
+        refresh_token
+        credit_card
+        card_number
+        cvv
+        ssn
+        social_security
+      ]
+    end
+  end
+end

data/lib/sciosano/context.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Sciosano
+  # Context holds user, tags, and extra data for reports
+  class Context
+    attr_accessor :user, :tags, :extra, :request
+
+    def initialize
+      @user = nil
+      @tags = {}
+      @extra = {}
+      @request = nil
+    end
+
+    # Merge additional context
+    #
+    # @param other [Hash, Context]
+    # @return [Context]
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    # Merge additional context in place
+    #
+    # @param other [Hash, Context]
+    # @return [self]
+    def merge!(other)
+      case other
+      when Context
+        @user = other.user if other.user
+        @tags.merge!(other.tags)
+        @extra.merge!(other.extra)
+        @request = other.request if other.request
+      when Hash
+        @user = other[:user] if other[:user]
+        @tags.merge!(other[:tags] || {})
+        @extra.merge!(other[:extra] || {})
+        @request = other[:request] if other[:request]
+      end
+      self
+    end
+
+    # Duplicate context
+    #
+    # @return [Context]
+    def dup
+      new_context = Context.new
+      new_context.user = @user&.dup
+      new_context.tags = @tags.dup
+      new_context.extra = @extra.dup
+      new_context.request = @request&.dup
+      new_context
+    end
+
+    # Convert to hash
+    #
+    # @return [Hash]
+    def to_h
+      {
+        user: user,
+        tags: tags,
+        extra: extra,
+        request: request
+      }.compact
+    end
+  end
+end

data/lib/sciosano/integrations/active_job.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Sciosano
+  module Integrations
+    # ActiveJob integration for capturing job errors
+    module ActiveJob
+      extend ActiveSupport::Concern
+
+      included do
+        around_perform :sciosano_capture_exceptions
+        after_enqueue :sciosano_enqueue_breadcrumb
+      end
+
+      private
+
+      def sciosano_capture_exceptions
+        # Add job breadcrumb
+        sciosano_add_job_breadcrumb
+
+        # Set job context
+        Sciosano.client&.with_context(
+          extra: {
+            active_job: self.class.name,
+            active_job_id: job_id,
+            active_job_queue: queue_name,
+            active_job_executions: executions
+          }
+        ) do
+          yield
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        sciosano_capture_exception(e)
+        raise
+      end
+
+      def sciosano_add_job_breadcrumb
+        return unless Sciosano.client
+
+        Sciosano.add_breadcrumb(
+          type: :default,
+          category: "active_job",
+          message: "Processing #{self.class.name}",
+          data: {
+            job_class: self.class.name,
+            job_id: job_id,
+            queue: queue_name,
+            priority: priority,
+            executions: executions
+          }.compact
+        )
+      end
+
+      def sciosano_capture_exception(exception)
+        return unless Sciosano.client
+
+        Sciosano.capture_exception(exception, {
+          tags: {
+            "active_job.queue" => queue_name,
+            "active_job.job" => self.class.name
+          },
+          extra: {
+            active_job: {
+              job_class: self.class.name,
+              job_id: job_id,
+              queue: queue_name,
+              priority: priority,
+              executions: executions,
+              scheduled_at: scheduled_at,
+              arguments: sanitize_arguments(arguments)
+            }
+          }
+        })
+      end
+
+      def sciosano_enqueue_breadcrumb
+        return unless Sciosano.client
+
+        Sciosano.add_breadcrumb(
+          type: :default,
+          category: "active_job",
+          message: "Enqueued #{self.class.name}",
+          data: {
+            job_class: self.class.name,
+            job_id: job_id,
+            queue: queue_name
+          }
+        )
+      end
+
+      def sanitize_arguments(args)
+        return [] unless args.is_a?(Array)
+
+        args.map do |arg|
+          case arg
+          when Hash
+            filter_sensitive_hash(arg)
+          when String
+            arg.length > 200 ? "#{arg[0..200]}..." : arg
+          when ActiveRecord::Base
+            "#{arg.class.name}##{arg.id}"
+          else
+            arg.inspect[0..200]
+          end
+        end
+      end
+
+      def filter_sensitive_hash(hash)
+        hash.transform_values do |value|
+          case value
+          when Hash
+            filter_sensitive_hash(value)
+          else
+            value
+          end
+        end.reject do |key, _|
+          key.to_s.downcase.match?(/password|secret|token|key|auth|credit|card/)
+        end
+      end
+
+      # Class methods
+      module ClassMethods
+        # Disable sciosano for specific job
+        def skip_sciosano_capture
+          skip_callback :perform, :around, :sciosano_capture_exceptions
+        end
+      end
+    end
+  end
+end
+
+# Auto-include in ActiveJob::Base when loaded
+ActiveSupport.on_load(:active_job) do
+  include Sciosano::Integrations::ActiveJob
+end if defined?(ActiveSupport)