solid_observer 0.1.0

data/lib/solid_observer/subscriber.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  # Subscribes to ActiveSupport::Notifications for ActiveJob events.
+  #
+  # Monitors job lifecycle events (enqueue, perform, retry_stopped, discard)
+  # and records them through the event buffer for observability.
+  #
+  # @example Subscribe to job events
+  #   SolidObserver::Subscriber.subscribe!
+  class Subscriber
+    EVENTS = %w[
+      enqueue.active_job
+      perform.active_job
+      retry_stopped.active_job
+      discard.active_job
+    ].freeze
+
+    class << self
+      def subscribe!
+        return unless SolidObserver.config.observe_queue
+        return if subscribed?
+
+        @subscriptions = []
+        @subscriptions << subscribe_to_enqueue
+        @subscriptions << subscribe_to_perform
+        @subscriptions << subscribe_to_retry_stopped
+        @subscriptions << subscribe_to_discard
+        @subscriptions.compact!
+      end
+
+      def unsubscribe!
+        return unless @subscriptions
+
+        @subscriptions.each do |subscription|
+          ActiveSupport::Notifications.unsubscribe(subscription)
+        end
+        @subscriptions = []
+      end
+
+      def subscribed?
+        !!@subscriptions&.any?
+      end
+
+      private
+
+      def subscribe_to_enqueue
+        ActiveSupport::Notifications.subscribe("enqueue.active_job") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          Services::RecordEvent.call(
+            event: event,
+            event_type: "job_enqueued",
+            buffer: QueueEventBuffer.instance,
+            metric_name: "jobs_enqueued"
+          )
+        end
+      end
+
+      def subscribe_to_perform
+        ActiveSupport::Notifications.subscribe("perform.active_job") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          Services::RecordEvent.call(
+            event: event,
+            event_type: "job_completed",
+            buffer: QueueEventBuffer.instance,
+            metric_name: "jobs_completed"
+          )
+        end
+      end
+
+      def subscribe_to_retry_stopped
+        ActiveSupport::Notifications.subscribe("retry_stopped.active_job") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          Services::RecordEvent.call(
+            event: event,
+            event_type: "job_failed",
+            buffer: QueueEventBuffer.instance,
+            metric_name: "jobs_failed"
+          )
+        end
+      end
+
+      def subscribe_to_discard
+        ActiveSupport::Notifications.subscribe("discard.active_job") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          Services::RecordEvent.call(
+            event: event,
+            event_type: "job_discarded",
+            buffer: QueueEventBuffer.instance,
+            metric_name: "jobs_discarded"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solid_observer/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  VERSION = "0.1.0"
+  RUBY_MINIMUM_VERSION = "3.2.0"
+  RAILS_MINIMUM_VERSION = "8.0"
+end

data/lib/solid_observer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "solid_observer/version"
+require_relative "solid_observer/configuration"
+require_relative "solid_observer/correlation_id_resolver"
+require_relative "solid_observer/base_event" if defined?(ActiveRecord)
+require_relative "solid_observer/base_metric" if defined?(ActiveRecord)
+require_relative "solid_observer/services/record_event" if defined?(ActiveRecord)
+require_relative "solid_observer/services/flush_event_buffer" if defined?(ActiveRecord)
+require_relative "solid_observer/services/cleanup_storage" if defined?(ActiveRecord)
+require_relative "solid_observer/queue_event_buffer" if defined?(ActiveRecord)
+require_relative "solid_observer/subscriber" if defined?(ActiveSupport)
+require_relative "solid_observer/cli/base"
+require_relative "solid_observer/cli/status"
+require_relative "solid_observer/cli/storage"
+require_relative "solid_observer/cli/jobs"
+require_relative "solid_observer/queue_stats"
+require_relative "solid_observer/engine" if defined?(Rails::Engine)
+
+module SolidObserver
+  class Error < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def config
+      configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/tasks/solid_observer.rake

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+namespace :solid_observer do
+  desc "Display SolidObserver version"
+  task :version do
+    puts "SolidObserver #{SolidObserver::VERSION}"
+    puts "Ruby: #{SolidObserver::RUBY_MINIMUM_VERSION}+"
+    puts "Rails: #{SolidObserver::RAILS_MINIMUM_VERSION}+"
+  end
+
+  namespace :install do
+    desc "Copy SolidObserver migrations to your application"
+    task migrations: :environment do
+      Rake::Task["railties:install:migrations"].reenable
+      Rake::Task["railties:install:migrations"].invoke
+    end
+  end
+
+  namespace :db do
+    desc "Create the SolidObserver database"
+    task create: :environment do
+      config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: "solid_observer_queue")
+      ActiveRecord::Tasks::DatabaseTasks.create(config)
+      puts "Created database '#{config.database}'"
+    end
+
+    desc "Migrate the SolidObserver database"
+    task migrate: :environment do
+      ActiveRecord::Tasks::DatabaseTasks.migrate
+      puts "Migrations complete"
+    end
+  end
+
+  namespace :buffer do
+    desc "Flush the event buffer to the database"
+    task flush: :environment do
+      buffer = SolidObserver::QueueEventBuffer.instance
+      buffer_size = buffer.size
+
+      if buffer_size.zero?
+        puts "Buffer is empty, nothing to flush"
+      else
+        puts "Flushing #{buffer_size} events from buffer..."
+        buffer.flush!
+        puts "✓ Buffer flushed successfully"
+      end
+    end
+
+    desc "Clear the event buffer without flushing to database"
+    task clear: :environment do
+      buffer = SolidObserver::QueueEventBuffer.instance
+      buffer_size = buffer.size
+
+      if buffer_size.zero?
+        puts "Buffer is already empty"
+      else
+        buffer.clear
+        puts "✓ Cleared #{buffer_size} events from buffer (not saved to database)"
+      end
+    end
+  end
+
+  namespace :storage do
+    desc "Run storage cleanup based on retention policy"
+    task cleanup: :environment do
+      retention = SolidObserver.config.event_retention
+      puts "Running storage cleanup (retention: #{retention.inspect})..."
+
+      deleted_count = SolidObserver::Services::CleanupStorage.call
+      puts "✓ Cleanup complete: #{deleted_count} old events deleted"
+    end
+
+    desc "Purge ALL SolidObserver storage data (use with caution!)"
+    task purge: :environment do
+      print "⚠️  This will delete ALL SolidObserver data (events + snapshots). Are you sure? (y/N) "
+      $stdout.flush
+
+      confirmation = $stdin.gets&.strip&.downcase
+      if confirmation == "y"
+        event_count = SolidObserver::QueueEvent.count
+        snapshot_count = SolidObserver::StorageInfo.count
+
+        SolidObserver::QueueEvent.delete_all
+        SolidObserver::StorageInfo.delete_all
+
+        connection = SolidObserver::QueueEvent.connection
+        case connection.adapter_name.downcase
+        when "sqlite"
+          connection.execute("VACUUM")
+          puts "✓ Database vacuumed to reclaim disk space"
+        when "postgresql"
+          connection.execute("ANALYZE solid_observer_queue_events")
+          connection.execute("ANALYZE solid_observer_storage_info")
+          puts "✓ Database tables analyzed"
+        end
+
+        puts "✓ Purged #{event_count} events and #{snapshot_count} storage snapshots"
+      else
+        puts "Aborted"
+      end
+    end
+  end
+
+  desc "Display SolidObserver status with queue statistics"
+  task status: :environment do
+    SolidObserver::CLI::Status.call
+  end
+
+  desc "Display storage information and database statistics"
+  task storage: :environment do
+    SolidObserver::CLI::Storage.call
+  end
+
+  namespace :jobs do
+    desc "List jobs with optional filters (status, queue, class, limit)"
+    task :list, [:status, :queue, :job_class, :limit] => :environment do |_t, args|
+      SolidObserver::CLI::Jobs.new.list(
+        status: args[:status],
+        queue: args[:queue],
+        job_class: args[:job_class],
+        limit: args[:limit] || 20
+      )
+    end
+
+    desc "Show details for a specific job by ID"
+    task :show, [:job_id] => :environment do |_t, args|
+      if args[:job_id].nil?
+        puts "Error: Job ID required. Usage: rails solid_observer:jobs:show[JOB_ID]"
+        exit 1
+      end
+
+      SolidObserver::CLI::Jobs.new.show(args[:job_id])
+    end
+
+    desc "Retry a failed job by ID"
+    task :retry, [:job_id] => :environment do |_t, args|
+      if args[:job_id].nil?
+        puts "Error: Job ID required. Usage: rails solid_observer:jobs:retry[JOB_ID]"
+        exit 1
+      end
+
+      SolidObserver::CLI::Jobs.new.retry_job(args[:job_id])
+    end
+
+    desc "Discard a failed job by ID"
+    task :discard, [:job_id] => :environment do |_t, args|
+      if args[:job_id].nil?
+        puts "Error: Job ID required. Usage: rails solid_observer:jobs:discard[JOB_ID]"
+        exit 1
+      end
+
+      SolidObserver::CLI::Jobs.new.discard(args[:job_id])
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: solid_observer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- BartOz
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+description: Production-grade observability for Rails 8's Solid Stack. Monitor ActiveJob
+  performance, track queue metrics, and debug issues with zero external dependencies.
+  Built-in CLI, retention policies, and APM integrations.
+email:
+- bartek.ozdoba@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- app/jobs/solid_observer/cleanup_job.rb
+- app/models/solid_observer/queue_event.rb
+- app/models/solid_observer/queue_metric.rb
+- app/models/solid_observer/storage_info.rb
+- bin/console
+- bin/setup
+- db/migrate/20260115000001_create_solid_observer_queue_events.rb
+- db/migrate/20260115000002_create_solid_observer_metrics.rb
+- db/migrate/20260115000003_create_solid_observer_storage_info.rb
+- lib/generators/solid_observer/install_generator.rb
+- lib/generators/solid_observer/templates/initializer.rb.tt
+- lib/solid_observer.rb
+- lib/solid_observer/base_event.rb
+- lib/solid_observer/base_metric.rb
+- lib/solid_observer/cli/base.rb
+- lib/solid_observer/cli/jobs.rb
+- lib/solid_observer/cli/status.rb
+- lib/solid_observer/cli/storage.rb
+- lib/solid_observer/configuration.rb
+- lib/solid_observer/correlation_id_resolver.rb
+- lib/solid_observer/engine.rb
+- lib/solid_observer/queue_event_buffer.rb
+- lib/solid_observer/queue_stats.rb
+- lib/solid_observer/services/cleanup_storage.rb
+- lib/solid_observer/services/flush_event_buffer.rb
+- lib/solid_observer/services/record_event.rb
+- lib/solid_observer/subscriber.rb
+- lib/solid_observer/version.rb
+- lib/tasks/solid_observer.rake
+homepage: https://solid.observer
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://solid.observer
+  source_code_uri: https://github.com/bart-oz/solid_observer
+  changelog_uri: https://github.com/bart-oz/solid_observer/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Observability for the Rails 8's Solid Stack
+test_files: []