solid_ops 0.1.0

data/lib/solid_ops/subscribers.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module SolidOps
+  module Subscribers
+    class << self
+      def install!
+        return unless SolidOps.configuration.enabled
+
+        subscribe_cable!
+        subscribe_jobs!
+        subscribe_cache!
+      end
+
+      private
+
+      def subscribe_cable!
+        ActiveSupport::Notifications.subscribe("broadcast.action_cable") do |*args|
+          e = ActiveSupport::Notifications::Event.new(*args)
+          p = e.payload || {}
+
+          record_event!(
+            event_type: "cable.broadcast",
+            name: (p[:broadcasting] || p[:stream] || p[:channel] || "unknown").to_s,
+            duration_ms: e.duration,
+            metadata: {
+              broadcasting: p[:broadcasting],
+              message_bytes: bytesize(p[:message])
+            }
+          )
+        end
+      end
+
+      def subscribe_jobs!
+        ActiveSupport::Notifications.subscribe("enqueue.active_job") do |*args|
+          e = ActiveSupport::Notifications::Event.new(*args)
+          p = e.payload || {}
+          job = p[:job]
+
+          record_event!(
+            event_type: "job.enqueue",
+            name: job_name(job),
+            duration_ms: e.duration,
+            metadata: job_metadata(job).merge(queue: p[:queue].to_s, adapter: p[:adapter].to_s)
+          )
+        end
+
+        ActiveSupport::Notifications.subscribe("perform_start.active_job") do |*args|
+          e = ActiveSupport::Notifications::Event.new(*args)
+          p = e.payload || {}
+          job = p[:job]
+
+          record_event!(
+            event_type: "job.perform_start",
+            name: job_name(job),
+            duration_ms: e.duration,
+            metadata: job_metadata(job)
+          )
+        end
+
+        ActiveSupport::Notifications.subscribe("perform.active_job") do |*args|
+          e = ActiveSupport::Notifications::Event.new(*args)
+          p = e.payload || {}
+          job = p[:job]
+
+          record_event!(
+            event_type: "job.perform",
+            name: job_name(job),
+            duration_ms: e.duration,
+            metadata: job_metadata(job).merge(exception: p[:exception_object]&.class&.name)
+          )
+        end
+      end
+
+      def subscribe_cache!
+        ActiveSupport::Notifications.subscribe("cache_read.active_support") do |*args|
+          e = ActiveSupport::Notifications::Event.new(*args)
+          p = e.payload || {}
+
+          record_event!(
+            event_type: "cache.read",
+            name: p[:key].to_s,
+            duration_ms: e.duration,
+            metadata: {
+              hit: p[:hit],
+              store: p[:store].to_s
+            }
+          )
+        end
+
+        ActiveSupport::Notifications.subscribe("cache_write.active_support") do |*args|
+          e = ActiveSupport::Notifications::Event.new(*args)
+          p = e.payload || {}
+
+          record_event!(
+            event_type: "cache.write",
+            name: p[:key].to_s,
+            duration_ms: e.duration,
+            metadata: {
+              store: p[:store].to_s,
+              value_bytes: bytesize(p[:value])
+            }
+          )
+        end
+
+        ActiveSupport::Notifications.subscribe("cache_delete.active_support") do |*args|
+          e = ActiveSupport::Notifications::Event.new(*args)
+          p = e.payload || {}
+
+          record_event!(
+            event_type: "cache.delete",
+            name: p[:key].to_s,
+            duration_ms: e.duration,
+            metadata: {
+              store: p[:store].to_s
+            }
+          )
+        end
+      end
+
+      def record_event!(event_type:, name:, duration_ms:, metadata:)
+        return if Thread.current[:solid_ops_recording]
+        return unless SolidOps.configuration.sample?
+
+        Thread.current[:solid_ops_recording] = true
+
+        SolidOps::Context.ensure_correlation_id!
+
+        meta = metadata || {}
+        meta = SolidOps.configuration.redactor.call(meta) if SolidOps.configuration.redactor
+        meta = truncate_meta(meta)
+
+        SolidOps::Event.create!(
+          event_type: event_type,
+          name: name.to_s,
+          correlation_id: SolidOps::Current.correlation_id,
+          request_id: SolidOps::Current.request_id,
+          tenant_id: SolidOps::Current.tenant_id,
+          actor_id: SolidOps::Current.actor_id,
+          duration_ms: duration_ms,
+          occurred_at: Time.current,
+          metadata: meta
+        )
+      rescue StandardError => e
+        Rails.logger.warn("[SolidOps] Failed to record event: #{e.class}: #{e.message}") if defined?(Rails.logger)
+        nil
+      ensure
+        Thread.current[:solid_ops_recording] = false
+      end
+
+      def truncate_meta(meta)
+        max = SolidOps.configuration.max_payload_bytes.to_i
+        safe = safe_serialize(meta)
+        return safe if max <= 0
+
+        json = safe.to_json
+        return safe if json.bytesize <= max
+
+        { truncated: true, max_bytes: max, bytes: json.bytesize }
+      rescue StandardError
+        { unserializable: true }
+      end
+
+      def job_name(job)
+        return "unknown" unless job
+
+        job.class.name.to_s
+      end
+
+      def job_metadata(job)
+        return {} unless job
+
+        {
+          job_id: job.job_id,
+          provider_job_id: job.provider_job_id,
+          queue_name: job.queue_name,
+          arguments: safe_arguments(job.arguments)
+        }
+      end
+
+      def safe_arguments(args)
+        max = SolidOps.configuration.max_payload_bytes.to_i
+        json = Array(args).map { |a| safe_serialize(a) }.to_json
+        return Array(args).map { |a| safe_serialize(a) } if max <= 0 || json.bytesize <= max
+
+        { truncated: true, max_bytes: max }
+      rescue StandardError
+        { unserializable: true }
+      end
+
+      def safe_serialize(obj)
+        case obj
+        when String, Numeric, NilClass, TrueClass, FalseClass
+          obj
+        when Hash
+          obj.transform_values { |v| safe_serialize(v) }
+        when Array
+          obj.map { |v| safe_serialize(v) }
+        else
+          obj.to_s
+        end
+      rescue StandardError
+        obj.class.name.to_s
+      end
+
+      def bytesize(value)
+        return nil if value.nil?
+
+        s = value.is_a?(String) ? value : value.to_s
+        s.bytesize
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/solid_ops/version.rb

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

data/lib/solid_ops.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "rails"
+require_relative "solid_ops/version"
+require_relative "solid_ops/configuration"
+require_relative "solid_ops/current"
+require_relative "solid_ops/context"
+require_relative "solid_ops/middleware"
+require_relative "solid_ops/job_extension"
+require_relative "solid_ops/subscribers"
+require_relative "solid_ops/engine"
+
+module SolidOps
+  class Error < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= SolidOps::Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/lib/tasks/solid_ops.rake

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+namespace :solid_ops do
+  desc "Purge events older than the configured retention period"
+  task purge: :environment do
+    retention = SolidOps.configuration.retention_period
+    unless retention
+      puts "No retention_period configured. Set SolidOps.configure { |c| c.retention_period = 7.days }"
+      next
+    end
+
+    cutoff = retention.ago
+    deleted = SolidOps::Event.purge!(before: cutoff)
+    puts "SolidOps: Purged #{deleted} events older than #{cutoff}"
+  end
+
+  desc "Show event count and storage stats"
+  task stats: :environment do
+    total = SolidOps::Event.count
+    oldest = SolidOps::Event.minimum(:occurred_at)
+    newest = SolidOps::Event.maximum(:occurred_at)
+
+    puts "SolidOps Event Stats"
+    puts "  Total events: #{total}"
+    puts "  Oldest: #{oldest || "none"}"
+    puts "  Newest: #{newest || "none"}"
+    puts ""
+    SolidOps::Event.group(:event_type).count.sort_by { |_, v| -v }.each do |type, count|
+      puts "  #{type}: #{count}"
+    end
+  end
+end

data/log/test.log

@@ -0,0 +1,2 @@
+[SolidOps] WARNING: No auth_check configured — the dashboard is publicly accessible. Set SolidOps.configure { |c| c.auth_check = ->(controller) { controller.current_user&.admin? } } in an initializer to restrict access.
+[SolidOps] WARNING: No auth_check configured — the dashboard is publicly accessible. Set SolidOps.configure { |c| c.auth_check = ->(controller) { controller.current_user&.admin? } } in an initializer to restrict access.

data/sig/solid_ops.rbs

@@ -0,0 +1,4 @@
+module SolidOps
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: solid_ops
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- samuel-murphy
+bindir: exe
+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: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: SolidOps provides a real-time dashboard and management UI for Solid Queue,
+  Solid Cache, and Solid Cable — built as a mountable Rails engine with zero JavaScript
+  dependencies.
+email:
+- samuelmurphy15@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/stylesheets/solid_ops/application.css
+- app/controllers/solid_ops/application_controller.rb
+- app/controllers/solid_ops/cache_entries_controller.rb
+- app/controllers/solid_ops/channels_controller.rb
+- app/controllers/solid_ops/dashboard_controller.rb
+- app/controllers/solid_ops/events_controller.rb
+- app/controllers/solid_ops/jobs_controller.rb
+- app/controllers/solid_ops/processes_controller.rb
+- app/controllers/solid_ops/queues_controller.rb
+- app/controllers/solid_ops/recurring_tasks_controller.rb
+- app/helpers/solid_ops/application_helper.rb
+- app/jobs/solid_ops/purge_job.rb
+- app/models/solid_ops/event.rb
+- app/views/layouts/solid_ops/application.html.erb
+- app/views/solid_ops/cache_entries/index.html.erb
+- app/views/solid_ops/cache_entries/show.html.erb
+- app/views/solid_ops/channels/index.html.erb
+- app/views/solid_ops/channels/show.html.erb
+- app/views/solid_ops/dashboard/cable.html.erb
+- app/views/solid_ops/dashboard/cache.html.erb
+- app/views/solid_ops/dashboard/index.html.erb
+- app/views/solid_ops/dashboard/jobs.html.erb
+- app/views/solid_ops/events/index.html.erb
+- app/views/solid_ops/events/show.html.erb
+- app/views/solid_ops/jobs/failed.html.erb
+- app/views/solid_ops/jobs/running.html.erb
+- app/views/solid_ops/jobs/show.html.erb
+- app/views/solid_ops/processes/index.html.erb
+- app/views/solid_ops/queues/index.html.erb
+- app/views/solid_ops/queues/show.html.erb
+- app/views/solid_ops/recurring_tasks/index.html.erb
+- app/views/solid_ops/shared/_nav.html.erb
+- app/views/solid_ops/shared/_pagination.html.erb
+- app/views/solid_ops/shared/_time_window.html.erb
+- app/views/solid_ops/shared/component_unavailable.html.erb
+- config/routes.rb
+- db/migrate/20260224000100_create_solid_ops_events.rb
+- lib/generators/solid_ops/install/install_generator.rb
+- lib/generators/solid_ops/install/templates/create_solid_ops_events.rb
+- lib/generators/solid_ops/install/templates/solid_ops_initializer.rb
+- lib/solid_ops.rb
+- lib/solid_ops/configuration.rb
+- lib/solid_ops/context.rb
+- lib/solid_ops/current.rb
+- lib/solid_ops/engine.rb
+- lib/solid_ops/job_extension.rb
+- lib/solid_ops/middleware.rb
+- lib/solid_ops/subscribers.rb
+- lib/solid_ops/version.rb
+- lib/tasks/solid_ops.rake
+- log/test.log
+- sig/solid_ops.rbs
+homepage: https://github.com/h0m1c1de/solid_ops
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/h0m1c1de/solid_ops
+  source_code_uri: https://github.com/h0m1c1de/solid_ops
+  changelog_uri: https://github.com/h0m1c1de/solid_ops/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: Rails-native observability and control plane for the Solid Trifecta
+test_files: []