sciosano 0.1.0

data/lib/sciosano/integrations/rack.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Sciosano
+  module Integrations
+    # Rack middleware for capturing exceptions in Rack applications
+    class RackMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        # Add request breadcrumb
+        add_request_breadcrumb(env)
+
+        # Set request context
+        Sciosano.client&.with_context(request: build_request_context(env)) do
+          @app.call(env)
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        # Capture exception but re-raise
+        capture_exception(e, env)
+        raise
+      end
+
+      private
+
+      def add_request_breadcrumb(env)
+        return unless Sciosano.client
+
+        method = env["REQUEST_METHOD"]
+        path = env["PATH_INFO"]
+
+        Sciosano.add_breadcrumb(
+          type: :http,
+          category: "request",
+          message: "#{method} #{path}",
+          data: {
+            method: method,
+            path: path,
+            query_string: env["QUERY_STRING"]
+          }.compact
+        )
+      end
+
+      def build_request_context(env)
+        request = Rack::Request.new(env)
+
+        {
+          url: request.url,
+          route: env["PATH_INFO"],
+          method: request.request_method,
+          query_string: request.query_string,
+          remote_ip: request.ip,
+          user_agent: request.user_agent,
+          referer: request.referer,
+          headers: extract_headers(env)
+        }.compact
+      end
+
+      def extract_headers(env)
+        headers = {}
+        env.each do |key, value|
+          next unless key.start_with?("HTTP_")
+          next if sensitive_header?(key)
+
+          header_name = key.sub(/^HTTP_/, "").split("_").map(&:capitalize).join("-")
+          headers[header_name] = value
+        end
+        headers
+      end
+
+      def sensitive_header?(key)
+        %w[HTTP_COOKIE HTTP_AUTHORIZATION HTTP_X_API_KEY].include?(key)
+      end
+
+      def capture_exception(exception, env)
+        return unless Sciosano.client
+
+        # Add additional request context
+        request = Rack::Request.new(env)
+
+        Sciosano.capture_exception(exception, {
+          request: {
+            url: request.url,
+            method: request.request_method,
+            params: filtered_params(request.params)
+          }
+        })
+      end
+
+      def filtered_params(params)
+        return {} unless params.is_a?(Hash)
+
+        Sciosano.configuration.filter_parameters.each do |filter|
+          params = filter_hash(params, filter)
+        end
+
+        params
+      end
+
+      def filter_hash(hash, filter)
+        hash.transform_values do |value|
+          case value
+          when Hash
+            filter_hash(value, filter)
+          else
+            value
+          end
+        end.transform_keys do |key|
+          if matches_filter?(key, filter)
+            "[FILTERED]"
+          else
+            key
+          end
+        end
+      end
+
+      def matches_filter?(key, filter)
+        case filter
+        when Regexp
+          filter.match?(key.to_s)
+        else
+          key.to_s.downcase.include?(filter.to_s.downcase)
+        end
+      end
+    end
+  end
+end

data/lib/sciosano/integrations/rails.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Sciosano
+  module Integrations
+    # Rails integration via Railtie
+    class Railtie < Rails::Railtie
+      initializer "Sciosano.configure_rails_initialization", before: :build_middleware_stack do |app|
+        # Insert Rack middleware BEFORE ShowExceptions so we can capture errors
+        # before Rails renders error pages
+        app.middleware.insert_before(
+          ActionDispatch::ShowExceptions,
+          Sciosano::Integrations::RackMiddleware
+        )
+      end
+
+      # Subscribe to ActiveSupport notifications for breadcrumbs
+      initializer "Sciosano.subscribe_to_notifications" do
+        # Subscribe to SQL queries
+        ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+
+          # Skip SCHEMA queries and very fast queries
+          next if event.payload[:name] == "SCHEMA"
+          next if event.duration < 1 # Skip queries under 1ms
+
+          Sciosano.add_breadcrumb(
+            type: :default,
+            category: "query",
+            message: event.payload[:name] || "SQL Query",
+            data: {
+              sql: event.payload[:sql]&.slice(0, 500),
+              duration: event.duration.round(2),
+              cached: event.payload[:cached]
+            }.compact
+          )
+        end
+
+        # Subscribe to controller actions
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+
+          Sciosano.add_breadcrumb(
+            type: :default,
+            category: "controller",
+            message: "#{event.payload[:controller]}##{event.payload[:action]}",
+            data: {
+              controller: event.payload[:controller],
+              action: event.payload[:action],
+              method: event.payload[:method],
+              path: event.payload[:path],
+              status: event.payload[:status],
+              duration: event.duration.round(2)
+            }.compact
+          )
+        end
+
+        # Subscribe to view rendering
+        ActiveSupport::Notifications.subscribe("render_template.action_view") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+
+          # Only track significant renders (over 5ms)
+          next if event.duration < 5
+
+          Sciosano.add_breadcrumb(
+            type: :default,
+            category: "view",
+            message: "Render #{event.payload[:identifier]}",
+            data: {
+              template: event.payload[:identifier],
+              duration: event.duration.round(2)
+            }
+          )
+        end
+
+        # Subscribe to cache operations
+        ActiveSupport::Notifications.subscribe(/cache_(read|write|delete)\.active_support/) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+
+          Sciosano.add_breadcrumb(
+            type: :default,
+            category: "cache",
+            message: "Cache #{event.name.split('.').first.sub('cache_', '')}",
+            data: {
+              key: event.payload[:key]&.to_s&.slice(0, 100),
+              hit: event.payload[:hit]
+            }.compact
+          )
+        end
+
+        # Subscribe to mailer events
+        ActiveSupport::Notifications.subscribe("deliver.action_mailer") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+
+          Sciosano.add_breadcrumb(
+            type: :default,
+            category: "mailer",
+            message: "Send #{event.payload[:mailer]}",
+            data: {
+              mailer: event.payload[:mailer],
+              to: event.payload[:to]&.first,
+              subject: event.payload[:subject]&.slice(0, 100)
+            }.compact
+          )
+        end
+      end
+
+      # Set user from controller
+      initializer "Sciosano.controller_extensions" do
+        ActiveSupport.on_load(:action_controller) do
+          include Sciosano::Integrations::ControllerExtensions
+        end
+      end
+
+      config.after_initialize do
+        # Auto-configure from Rails
+        if Sciosano.configuration.api_key && !Sciosano.client
+          Sciosano.configure do |config|
+            config.environment = Rails.env
+            config.release ||= Rails.application.class.module_parent_name
+          end
+        end
+      end
+    end
+
+    # Controller extensions for setting user context
+    module ControllerExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        around_action :sciosano_set_context, if: -> { Sciosano.client }
+      end
+
+      private
+
+      def sciosano_set_context
+        # Set user if method exists
+        if respond_to?(:current_user, true) && current_user
+          Sciosano.set_user(
+            id: current_user.try(:id),
+            email: current_user.try(:email),
+            name: current_user.try(:name) || current_user.try(:full_name)
+          )
+        end
+
+        yield
+      ensure
+        Sciosano.clear_user
+      end
+    end
+  end
+end

data/lib/sciosano/integrations/sidekiq.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Sciosano
+  module Integrations
+    # Sidekiq middleware for capturing job errors
+    module Sidekiq
+      # Server middleware (runs on job worker)
+      class ServerMiddleware
+        def call(worker, job, queue)
+          # Add job breadcrumb
+          add_job_breadcrumb(worker, job, queue)
+
+          # Set job context
+          Sciosano.client&.with_context(
+            extra: {
+              sidekiq_job: job["class"],
+              sidekiq_queue: queue,
+              sidekiq_jid: job["jid"],
+              sidekiq_retry_count: job["retry_count"]
+            }
+          ) do
+            yield
+          end
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          capture_exception(e, worker, job, queue)
+          raise
+        end
+
+        private
+
+        def add_job_breadcrumb(worker, job, queue)
+          return unless Sciosano.client
+
+          Sciosano.add_breadcrumb(
+            type: :default,
+            category: "sidekiq",
+            message: "Processing #{job['class']}",
+            data: {
+              job_class: job["class"],
+              queue: queue,
+              jid: job["jid"],
+              args_count: job["args"]&.size || 0
+            }
+          )
+        end
+
+        def capture_exception(exception, worker, job, queue)
+          return unless Sciosano.client
+
+          # Include job context in report
+          Sciosano.capture_exception(exception, {
+            tags: {
+              "sidekiq.queue" => queue,
+              "sidekiq.job" => job["class"]
+            },
+            extra: {
+              sidekiq: {
+                job_class: job["class"],
+                queue: queue,
+                jid: job["jid"],
+                args: sanitize_args(job["args"]),
+                retry_count: job["retry_count"],
+                created_at: job["created_at"],
+                enqueued_at: job["enqueued_at"]
+              }
+            }
+          })
+        end
+
+        def sanitize_args(args)
+          return [] unless args.is_a?(Array)
+
+          args.map do |arg|
+            case arg
+            when Hash
+              filter_sensitive_data(arg)
+            when String
+              arg.length > 200 ? "#{arg[0..200]}..." : arg
+            else
+              arg
+            end
+          end
+        end
+
+        def filter_sensitive_data(hash)
+          hash.transform_values do |value|
+            case value
+            when Hash
+              filter_sensitive_data(value)
+            else
+              value
+            end
+          end.transform_keys do |key|
+            if sensitive_key?(key)
+              "[FILTERED]"
+            else
+              key
+            end
+          end
+        end
+
+        def sensitive_key?(key)
+          key.to_s.downcase.match?(/password|secret|token|key|auth|credit|card/)
+        end
+      end
+
+      # Client middleware (runs when job is enqueued)
+      class ClientMiddleware
+        def call(worker_class, job, queue, redis_pool)
+          # Add enqueue breadcrumb
+          Sciosano.add_breadcrumb(
+            type: :default,
+            category: "sidekiq",
+            message: "Enqueued #{worker_class}",
+            data: {
+              job_class: worker_class.to_s,
+              queue: queue,
+              jid: job["jid"]
+            }
+          ) if Sciosano.client
+
+          yield
+        end
+      end
+
+      # Register Sidekiq middleware
+      def self.setup
+        ::Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add ServerMiddleware
+          end
+
+          config.client_middleware do |chain|
+            chain.add ClientMiddleware
+          end
+
+          # Also register as error handler for guaranteed capture
+          # This catches errors even if middleware chain has timing issues
+          config.error_handlers << proc do |exception, context|
+            next unless Sciosano.client
+
+            Sciosano.capture_exception(exception, {
+              tags: {
+                "sidekiq.error_handler" => "true"
+              },
+              extra: {
+                sidekiq_context: context
+              }
+            })
+          end
+        end
+
+        ::Sidekiq.configure_client do |config|
+          config.client_middleware do |chain|
+            chain.add ClientMiddleware
+          end
+        end
+      end
+    end
+  end
+end
+
+# Auto-setup when loaded
+Sciosano::Integrations::Sidekiq.setup if defined?(::Sidekiq)

data/lib/sciosano/report.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Sciosano
+  # Report represents an error or message to be sent to sciosano
+  class Report
+    attr_reader :id, :report_type, :source, :error, :user_description,
+                :context, :environment, :breadcrumbs, :tags, :timestamp
+
+    def initialize(attrs = {})
+      @id = attrs[:id] || SecureRandom.uuid
+      @report_type = attrs[:report_type] || "error"
+      @source = attrs[:source] || "backend"
+      @error = attrs[:error]
+      @user_description = attrs[:user_description]
+      @context = attrs[:context] || {}
+      @environment = attrs[:environment] || {}
+      @breadcrumbs = attrs[:breadcrumbs] || []
+      @tags = attrs[:tags] || {}
+      @timestamp = attrs[:timestamp] || Time.now.utc.iso8601(3)
+    end
+
+    # Build report from an exception
+    #
+    # @param exception [Exception]
+    # @param context [Context]
+    # @param breadcrumbs [Array<Breadcrumb>]
+    # @param configuration [Configuration]
+    # @return [Report]
+    def self.build_from_exception(exception, context:, breadcrumbs:, configuration:)
+      new(
+        report_type: "error",
+        source: "backend",
+        error: build_error_hash(exception),
+        context: build_context_hash(context, configuration),
+        environment: build_environment_hash(configuration),
+        breadcrumbs: breadcrumbs.map(&:to_h),
+        tags: context.tags
+      )
+    end
+
+    # Build report from a message
+    #
+    # @param message [String]
+    # @param level [Symbol]
+    # @param context [Context]
+    # @param breadcrumbs [Array<Breadcrumb>]
+    # @param configuration [Configuration]
+    # @return [Report]
+    def self.build_from_message(message, level:, context:, breadcrumbs:, configuration:)
+      new(
+        report_type: "feedback",
+        source: "backend",
+        user_description: message,
+        context: build_context_hash(context, configuration),
+        environment: build_environment_hash(configuration),
+        breadcrumbs: breadcrumbs.map(&:to_h),
+        tags: context.tags.merge("level" => level.to_s)
+      )
+    end
+
+    # Convert to JSON for API
+    #
+    # @return [String]
+    def to_json(*_args)
+      JSON.generate(to_h)
+    end
+
+    # Convert to hash
+    #
+    # @return [Hash]
+    def to_h
+      {
+        reportType: report_type,
+        source: source,
+        error: error,
+        userDescription: user_description,
+        context: context,
+        environment: environment,
+        breadcrumbs: breadcrumbs,
+        tags: tags,
+        timestamp: timestamp
+      }.compact
+    end
+
+    class << self
+      private
+
+      def build_error_hash(exception)
+        hash = {
+          name: exception.class.name,
+          message: exception.message,
+          file: extract_file(exception.backtrace),
+          line: extract_line(exception.backtrace)
+        }.compact
+
+        # stackTrace is required, always include it (even if empty string)
+        hash[:stackTrace] = format_backtrace(exception.backtrace)
+        hash
+      end
+
+      def format_backtrace(backtrace)
+        return "" unless backtrace
+
+        backtrace.first(50).join("\n")
+      end
+
+      def extract_file(backtrace)
+        return nil unless backtrace&.first
+
+        match = backtrace.first.match(/^(.+):(\d+)/)
+        match&.[](1)
+      end
+
+      def extract_line(backtrace)
+        return nil unless backtrace&.first
+
+        match = backtrace.first.match(/^(.+):(\d+)/)
+        match&.[](2)&.to_i
+      end
+
+      def build_context_hash(context, configuration)
+        hash = {
+          userId: context.user&.dig(:id)&.to_s,
+          userEmail: context.user&.dig(:email),
+          custom: filter_params(context.extra, configuration.filter_parameters),
+          url: context.request&.dig(:url) || ""
+        }.compact
+
+        # url is required, ensure it's always present even after compact
+        hash[:url] ||= ""
+
+        # Add route if available
+        if context.request&.dig(:route)
+          hash[:route] = context.request[:route]
+        end
+
+        hash
+      end
+
+      def build_environment_hash(configuration)
+        {
+          rubyVersion: RUBY_VERSION,
+          rubyPlatform: RUBY_PLATFORM,
+          hostname: Socket.gethostname,
+          nodeEnv: configuration.environment,
+          appVersion: configuration.release,
+          railsVersion: defined?(Rails) ? Rails.version : nil,
+          sidekiqVersion: defined?(Sidekiq) ? Sidekiq::VERSION : nil
+        }.compact
+      end
+
+      def filter_params(hash, filters)
+        return hash if filters.empty?
+
+        hash.transform_values do |value|
+          case value
+          when Hash
+            filter_params(value, filters)
+          else
+            value
+          end
+        end.reject do |key, _|
+          filters.any? do |filter|
+            case filter
+            when Regexp
+              filter.match?(key.to_s)
+            else
+              key.to_s.downcase.include?(filter.to_s.downcase)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sciosano/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sciosano
+  VERSION = "0.1.0"
+end