solid_observer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 67f33210e5da882874417d97b040e5c1ea8a30b4cf5f628645fa76405bd38379
+  data.tar.gz: ffa7843af6bdd14bc23762da2f42a245073bf4776ec6b2de1aece77852c41d9d
+SHA512:
+  metadata.gz: 3b8ca565611c5a343b55131fa63d84ff5ad8c47a954b9103914764d90a1d381b6dcd39923c71b9c467011c2f6f0bc17cb724a8b8a60e16eef32110142088b007
+  data.tar.gz: 73e295dd624824b396bcd0ccca2c4d740f3f27287ce226b7816a92569193b996527e6cd5c8e0967c67a18b1b9c19fe100163ee49d5a5d3ebcb6e5b18624fa9bd

data/CHANGELOG.md

@@ -0,0 +1,58 @@
+## [0.1.0] - 2026-02-02
+
+### Added
+
+#### Core Infrastructure
+- Configuration DSL with 17 configurable attributes
+- Rails Engine setup for seamless integration
+- Separate database support for observability data
+- Module-level `configure`, `config`, and `reset_configuration!` methods
+- **QueueEvent validations** with `EVENT_TYPES`
+- **Configuration validation**
+- **Thread error handling** in `QueueEventBuffer#schedule_flush`
+
+#### Queue Monitoring
+- Real-time Solid Queue status monitoring (ready, scheduled, claimed, failed jobs)
+- Queue depth tracking per queue name
+- Worker count monitoring
+- Event collection with buffered writes for performance
+- **CleanupJob** inherits from `ActiveJob::Base` for better engine isolation
+- **Database maintenance** commands are adapter-aware (SQLite VACUUM, PostgreSQL VACUUM ANALYZE, MySQL OPTIMIZE TABLE)
+- **Subscriber** includes idempotency check to prevent duplicate subscriptions
+- **RecordEvent** properly populates `job_class` and `queue_name` columns
+
+#### CLI Tools
+- `solid_observer:status` — Queue overview with formatted tables
+- `solid_observer:jobs:list` — List jobs with filters (status, queue, job_class, limit)
+- `solid_observer:jobs:show` — Detailed job inspection
+- `solid_observer:jobs:retry` — Retry failed jobs with confirmation
+- `solid_observer:jobs:discard` — Discard failed jobs with confirmation
+- `solid_observer:storage` — Storage statistics and configuration
+
+#### Database & Migrations
+- Queue events migration with indexes for efficient queries
+- Metrics migration for aggregated data
+- Storage info migration for tracking database health
+- Automatic cleanup job for data retention
+
+#### APM Integration
+- `correlation_id_generator` option for distributed tracing
+- Built-in support for Datadog, Sentry, and OpenTelemetry
+- Custom correlation ID generator support
+
+#### Performance
+- Buffered event writes (configurable buffer size and flush interval)
+- Sampling rate configuration for high-traffic applications
+- Insert batching with `insert_all!` for bulk operations
+
+#### Developer Experience
+- Rails generator: `rails generate solid_observer:install`
+- Production-aware defaults (UI disabled in production)
+- Rails idiomatic time helpers (30.days, 10.seconds)
+- Comprehensive test suite (250+ tests)
+
+#### Quality & CI
+- Multi-version testing (Ruby 3.2-4.0, Rails 8.0-8.1)
+- Code quality: StandardRB, Reek, SimpleCov (95%+ coverage)
+- Security scanning: bundler-audit, brakeman
+- Performance benchmarks

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 BartOz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,347 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset=".github/solid_logo_dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset=".github/solid_logo_light.svg">
+    <img alt="SolidObserver" src=".github/solid_logo_light.svg" width="250">
+  </picture>
+</p>
+
+<p align="center">
+  <strong>Observe your Solid Stack like a pro!</strong>
+</p>
+
+<p align="center">
+  <a href="https://github.com/bart-oz/solid_observer/releases"><img src="https://img.shields.io/badge/version-0.1.0-blue.svg" alt="Version"></a>
+  <a href="LICENSE.txt"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
+  <a href="https://github.com/bart-oz/solid_observer/actions"><img src="https://img.shields.io/badge/tests-passing-brightgreen.svg" alt="Tests"></a>
+  <a href="https://github.com/bart-oz/solid_observer/actions"><img src="https://img.shields.io/badge/coverage-93.23%25-brightgreen.svg" alt="Coverage"></a>
+</p>
+
+---
+
+SolidObserver is a production-grade observability solution for Rails 8's Solid Stack. Starting with **Solid Queue** monitoring in v0.1.0, it provides unified visibility into your background job processing with CLI tools, metrics collection, and distributed tracing support.
+
+## Features (v0.1.0)
+
+- 📊 **Real-time Queue Status** — Monitor jobs across all states (ready, scheduled, claimed, failed)
+- 🔍 **Job Management CLI** — List, inspect, retry, and discard failed jobs
+- 💾 **Storage Monitoring** — Track database size and event counts
+- 🔗 **Distributed Tracing** — Correlate jobs with APM tools (Datadog, Sentry, OpenTelemetry)
+- ⚡ **High Performance** — Buffered writes, configurable sampling, minimal overhead
+- 🛡️ **Production Ready** — Automatic cleanup, size limits, retention policies
+
+## Requirements
+
+- Ruby 3.2+
+- Rails 8.0+
+- Solid Queue (properly configured for all environments)
+
+> **Note:** Ensure Solid Queue is configured with `connects_to` in all environments, not just production. See [Troubleshooting](#troubleshooting) if you encounter database connection issues.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "solid_observer"
+```
+
+Run the installer:
+
+```bash
+bundle install
+rails generate solid_observer:install
+```
+
+Install and run migrations:
+
+```bash
+bin/rails solid_observer:install:migrations
+bin/rails db:create
+bin/rails db:migrate
+```
+
+## Quick Start
+
+### Check Queue Status
+
+```bash
+bin/rails solid_observer:status
+```
+
+Output:
+```
+📊 SolidObserver Status
+==================================================
+
+🚀 Solid Queue
+
+| Metric    | Value |
+|-----------|-------|
+| Ready     | 42    |
+| Scheduled | 15    |
+| Claimed   | 3     |
+| Failed    | 2     |
+| Workers   | 4     |
+
+📋 Queue Depths
+
+| Queue      | Jobs |
+|------------|------|
+| default    | 38   |
+| mailers    | 12   |
+| critical   | 10   |
+```
+
+### Manage Jobs
+
+```bash
+# List jobs (defaults to ready jobs)
+bin/rails solid_observer:jobs:list
+
+# List failed jobs
+bin/rails "solid_observer:jobs:list[failed]"
+
+# Filter by status, queue, job class, and limit
+bin/rails "solid_observer:jobs:list[failed,mailers]"
+bin/rails "solid_observer:jobs:list[ready,default,UserNotificationJob,50]"
+
+# Inspect a specific job
+bin/rails "solid_observer:jobs:show[JOB_ID]"
+
+# Retry a failed job
+bin/rails "solid_observer:jobs:retry[JOB_ID]"
+
+# Discard a failed job
+bin/rails "solid_observer:jobs:discard[JOB_ID]"
+```
+
+### Check Storage
+
+```bash
+bin/rails solid_observer:storage
+```
+
+Output:
+```
+💾 Storage Status
+
+| Component | Size    | Events | Usage | Status |
+|-----------|---------|--------|-------|--------|
+| Queue     | 12.5 MB | 45,231 | 1.2%  | ✓      |
+
+Configuration:
+  Retention: 30 days
+  Max size:  1024.0 MB per database
+  Warning:   80% threshold
+```
+
+## Configuration
+
+After installation, configure SolidObserver in `config/initializers/solid_observer.rb`:
+
+```ruby
+SolidObserver.configure do |config|
+  # Enable queue monitoring (default: true)
+  config.observe_queue = true
+
+  # Data Retention
+  config.event_retention = 30.days    # Keep events for 30 days
+  config.metrics_retention = 90.days  # Keep metrics for 90 days
+
+  # Database Limits
+  config.max_db_size = 1.gigabyte     # Maximum database size
+  config.warning_threshold = 0.8      # Warn at 80% capacity
+
+  # Performance Tuning
+  config.buffer_size = 1000           # Buffer before flushing to DB
+  config.flush_interval = 10.seconds  # Flush interval
+  config.sampling_rate = 1.0          # 1.0 = capture all events
+end
+```
+
+### APM Integration
+
+Connect SolidObserver with your Application Performance Monitoring tool for distributed tracing:
+
+```ruby
+SolidObserver.configure do |config|
+  # Datadog APM
+  config.correlation_id_generator = -> {
+    Datadog::Tracing.active_trace&.id
+  }
+
+  # Sentry
+  config.correlation_id_generator = -> {
+    Sentry.get_current_scope&.transaction&.trace_id
+  }
+
+  # OpenTelemetry
+  config.correlation_id_generator = -> {
+    OpenTelemetry::Trace.current_span&.context&.trace_id
+  }
+
+  # Custom implementation
+  config.correlation_id_generator = -> {
+    Thread.current[:request_id] || SecureRandom.uuid
+  }
+end
+```
+
+When configured, all job events will include your correlation ID, allowing you to trace jobs back to the originating request.
+
+## CLI Reference
+
+| Command | Description |
+|---------|-------------|
+| `solid_observer:status` | Show queue status overview |
+| `solid_observer:jobs:list[status,queue,class,limit]` | List jobs with optional filters |
+| `solid_observer:jobs:show[ID]` | Show job details |
+| `solid_observer:jobs:retry[ID]` | Retry a failed job |
+| `solid_observer:jobs:discard[ID]` | Discard a failed job |
+| `solid_observer:storage` | Show storage statistics |
+| `solid_observer:buffer:flush` | Force flush event buffer to database |
+| `solid_observer:buffer:clear` | Clear buffer without saving |
+| `solid_observer:storage:cleanup` | Run retention-based cleanup |
+| `solid_observer:storage:purge` | Delete ALL SolidObserver data |
+
+> **Note:** These commands manage **SolidObserver's storage** (event logs, metrics, snapshots) - not Solid Queue's jobs. To manage jobs, use `jobs:discard` or `jobs:retry`.
+
+### Jobs List Arguments
+
+Arguments are positional: `[status, queue, job_class, limit]`
+
+| Position | Description | Example |
+|----------|-------------|---------|
+| 1st | Filter by status | `failed`, `ready`, `scheduled` |
+| 2nd | Filter by queue name | `default`, `mailers` |
+| 3rd | Filter by job class | `UserNotificationJob` |
+| 4th | Max results (default: 20) | `50` |
+
+```bash
+# Examples
+bin/rails solid_observer:jobs:list                           # All ready jobs
+bin/rails "solid_observer:jobs:list[failed]"                 # Failed jobs
+bin/rails "solid_observer:jobs:list[ready,mailers]"          # Ready jobs in mailers queue
+bin/rails "solid_observer:jobs:list[failed,,,50]"            # 50 failed jobs (skip queue/class)
+```
+
+### Buffer & Storage Management
+
+```bash
+# Flush in-memory buffer to database
+bin/rails solid_observer:buffer:flush
+
+# Clear buffer without saving (loses pending events!)
+bin/rails solid_observer:buffer:clear
+
+# Run cleanup based on retention policy (default: 30 days)
+bin/rails solid_observer:storage:cleanup
+
+# Delete ALL SolidObserver data (events + snapshots, interactive confirmation)
+bin/rails solid_observer:storage:purge
+```
+
+> **Important:** `storage:purge` deletes SolidObserver's monitoring data, NOT your Solid Queue jobs. Your queued jobs remain safe.
+
+## Database Setup
+
+**SolidObserver works with any main application database** — PostgreSQL, MySQL, or SQLite.
+
+For its own monitoring data, SolidObserver uses a **separate SQLite database**. This keeps monitoring isolated from your main app and provides simple file-based storage that requires no additional infrastructure.
+
+```yaml
+# config/database.yml
+solid_observer_queue:
+  <<: *default
+  adapter: sqlite3  # Always SQLite for SolidObserver storage
+  database: storage/<%= Rails.env %>_solid_observer_queue.sqlite3
+```
+
+> **Note:** Your main app's `primary` database can be PostgreSQL, MySQL, or any Rails-supported adapter. Only the `solid_observer_queue` database needs to be SQLite.
+
+## Roadmap
+
+SolidObserver is actively developed. Here's what's coming:
+
+| Version | Focus | Status |
+|---------|-------|--------|
+| v0.1.0 | Solid Queue monitoring, CLI tools | ✅ Current |
+| v0.2.0 | Solid Cache monitoring | 🔜 Planned |
+| v0.3.0 | Solid Cable monitoring | 🔜 Planned |
+| v0.4.0 | Cross-component correlation, health scores | 🔜 Planned |
+| v0.5.0 | Alerting & notifications | 🔜 Planned |
+| v0.6.0 | Web UI dashboard | 🔜 Planned |
+| v1.0.0 | Production stable release | 🎯 Goal |
+
+See [GitHub Milestones](https://github.com/bart-oz/solid_observer/milestones) for detailed plans.
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/bart-oz/solid_observer.git
+cd solid_observer
+
+# Install dependencies
+bin/setup
+
+# Run tests
+bundle exec rspec
+
+# Run linter
+bundle exec standardrb
+
+# Run code smell detector
+bundle exec reek
+```
+
+## Troubleshooting
+
+### "no such table: solid_queue_ready_executions"
+
+This error means Solid Queue isn't configured to use the correct database in your environment.
+
+**Solution:** Ensure `connects_to` is configured for all environments, not just production:
+
+```ruby
+# config/environments/development.rb
+config.solid_queue.connects_to = { database: { writing: :queue } }
+
+# config/environments/test.rb
+config.solid_queue.connects_to = { database: { writing: :queue } }
+```
+
+### Multi-database setup
+
+SolidObserver works with Rails multi-database configurations. Here's an example with PostgreSQL as your primary database:
+
+```yaml
+development:
+  primary:
+    adapter: postgresql
+    database: myapp_development
+    # ... PostgreSQL settings
+  queue:
+    <<: *default
+    adapter: sqlite3
+    database: storage/development_queue.sqlite3
+    migrations_paths: db/queue_migrate
+  solid_observer_queue:
+    adapter: sqlite3
+    database: storage/development_solid_observer_queue.sqlite3
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/bart-oz/solid_observer).
+
+Check out issues labeled:
+- [good first issue](https://github.com/bart-oz/solid_observer/labels/good%20first%20issue) — Great for newcomers
+- [help wanted](https://github.com/bart-oz/solid_observer/labels/help%20wanted) — We'd love your help
+
+Please follow the [code of conduct](https://github.com/bart-oz/solid_observer/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/jobs/solid_observer/cleanup_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CleanupJob < ActiveJob::Base
+    queue_as :default
+    retry_on StandardError, wait: :exponentially_longer, attempts: 3
+
+    def perform
+      Services::CleanupStorage.call
+    end
+  end
+end

data/app/models/solid_observer/queue_event.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class QueueEvent < BaseEvent
+    self.table_name = "solid_observer_queue_events"
+
+    EVENT_TYPES = %w[
+      job_enqueued
+      job_completed
+      job_failed
+      job_discarded
+    ].freeze
+
+    validates :event_type, presence: true, inclusion: {in: EVENT_TYPES}
+    validates :recorded_at, presence: true
+
+    scope :by_job_class, ->(job_class) { where(job_class: job_class) }
+    scope :by_queue, ->(queue_name) { where(queue_name: queue_name) }
+    scope :by_event_type, ->(event_type) { where(event_type: event_type) }
+    scope :since, ->(time) { where("recorded_at >= ?", time) }
+    scope :before, ->(time) { where("recorded_at < ?", time) }
+  end
+end

data/app/models/solid_observer/queue_metric.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  # QueueMetric provides time-series metrics storage for queue statistics.
+  #
+  # NOTE: Metrics functionality is planned for v0.2.0. This class currently
+  # serves as a placeholder and inherits base functionality from BaseMetric.
+  # The database connection will be configured by the Engine when metrics
+  # are fully implemented.
+  #
+  # @see BaseMetric for available methods (increment, record)
+  class QueueMetric < BaseMetric
+  end
+end

data/app/models/solid_observer/storage_info.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class StorageInfo < BaseEvent
+    self.table_name = "solid_observer_storage_info"
+
+    MB_TO_BYTES = 1_048_576
+    GB_TO_BYTES = 1_073_741_824
+
+    validates :db_size_bytes, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
+    validates :event_count, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
+    validates :recorded_at, presence: true
+
+    scope :recent, ->(limit = 10) { order(recorded_at: :desc).limit(limit) }
+    scope :since, ->(time) { where("recorded_at >= ?", time) }
+
+    def self.record_snapshot(db_size:, event_count:)
+      create!(
+        db_size_bytes: db_size || 0,
+        event_count: event_count,
+        recorded_at: Time.current
+      )
+    rescue ActiveRecord::RecordInvalid => e
+      Rails.logger.error "[SolidObserver] Failed to record storage snapshot: #{e.message}"
+      raise
+    end
+
+    def db_size_mb
+      (db_size_bytes / MB_TO_BYTES.to_f).round(2)
+    end
+
+    def db_size_gb
+      (db_size_bytes / GB_TO_BYTES.to_f).round(2)
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "solid_observer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/db/migrate/20260115000001_create_solid_observer_queue_events.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class CreateSolidObserverQueueEvents < ActiveRecord::Migration[8.0]
+  def change
+    create_table :solid_observer_queue_events do |t|
+      t.string :event_type, null: false, limit: 50
+      t.string :job_class, limit: 100
+      t.string :queue_name, limit: 50
+      t.string :correlation_id, limit: 64
+      t.text :metadata
+      t.float :duration
+      t.datetime :recorded_at, null: false
+
+      t.index :recorded_at
+      t.index :correlation_id, where: "correlation_id IS NOT NULL"
+      t.index :event_type
+      t.index :job_class
+      t.index :queue_name
+    end
+  end
+end

data/db/migrate/20260115000002_create_solid_observer_metrics.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateSolidObserverMetrics < ActiveRecord::Migration[8.0]
+  def change
+    create_table :solid_observer_metrics do |t|
+      t.string :metric_name, null: false, limit: 50
+      t.bigint :value, null: false, default: 0
+      t.datetime :period_start, null: false
+      t.string :period_type, null: false, limit: 10
+
+      t.index [:metric_name, :period_start, :period_type],
+        unique: true,
+        name: "idx_solid_observer_metrics_unique"
+    end
+  end
+end

data/db/migrate/20260115000003_create_solid_observer_storage_info.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class CreateSolidObserverStorageInfo < ActiveRecord::Migration[8.0]
+  def change
+    create_table :solid_observer_storage_info do |t|
+      t.bigint :db_size_bytes, null: false
+      t.bigint :event_count, null: false
+      t.datetime :recorded_at, null: false
+
+      t.index :recorded_at
+    end
+  end
+end

data/lib/generators/solid_observer/install_generator.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module SolidObserver
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Install SolidObserver with initializer and database configuration"
+
+      def create_initializer
+        template "initializer.rb.tt", "config/initializers/solid_observer.rb"
+      end
+
+      def add_database_configuration
+        %w[development test production].each do |env|
+          config_block = <<-YAML
+  solid_observer_queue:
+    <<: *default
+    database: storage/#{env}_solid_observer_queue.sqlite3
+          YAML
+          inject_into_file "config/database.yml", config_block, after: /^#{env}:\n(?:  .*\n)*/
+        end
+      end
+
+      def show_instructions
+        say "\n"
+        print_banner
+        say "\n"
+        say "Next steps:", :yellow
+        say "  1. Review configuration in config/initializers/solid_observer.rb"
+        say "  2. Install migrations: bin/rails solid_observer:install:migrations"
+        say "  3. Create database: bin/rails db:create"
+        say "  4. Run migrations: bin/rails db:migrate"
+        say "  5. Restart your Rails server"
+        say "\n"
+        say "Documentation: https://solid.observer", :cyan
+        say "GitHub: https://github.com/bart-oz/solid_observer", :cyan
+        say "\n"
+      end
+
+      private
+
+      def print_banner
+        banner = <<~BANNER
+
+          ███████╗ ██████╗ ██╗     ██╗██████╗
+          ██╔════╝██╔═══██╗██║     ██║██╔══██╗
+          ███████╗██║   ██║██║     ██║██║  ██║
+          ╚════██║██║   ██║██║     ██║██║  ██║
+          ███████║╚██████╔╝███████╗██║██████╔╝
+          ╚══════╝ ╚═════╝ ╚══════╝╚═╝╚═════╝
+
+           ██████╗ ██████╗ ███████╗███████╗██████╗ ██╗   ██╗███████╗██████╗
+          ██╔═══██╗██╔══██╗██╔════╝██╔════╝██╔══██╗██║   ██║██╔════╝██╔══██╗
+          ██║   ██║██████╔╝███████╗█████╗  ██████╔╝██║   ██║█████╗  ██████╔╝
+          ██║   ██║██╔══██╗╚════██║██╔══╝  ██╔══██╗╚██╗ ██╔╝██╔══╝  ██╔══██╗
+          ╚██████╔╝██████╔╝███████║███████╗██║  ██║ ╚████╔╝ ███████╗██║  ██║
+           ╚═════╝ ╚═════╝ ╚══════╝╚══════╝╚═╝  ╚═╝  ╚═══╝  ╚══════╝╚═╝  ╚═╝
+
+                 Observe your Solid Stack like a pro! 🔭
+                                v#{SolidObserver::VERSION}
+
+        BANNER
+
+        banner.each_line { |line| say line.chomp, :cyan }
+        say "  ✓ SolidObserver installed successfully!", :green
+      end
+    end
+  end
+end