solid_cache_dashboard 0.0.1

data/lib/solid_cache_dashboard/decorators/cache_event_decorator.rb

@@ -0,0 +1,72 @@
+module SolidCacheDashboard
+  module Decorators
+    class CacheEventDecorator
+      def initialize(event)
+        @event = event
+      end
+
+      def id
+        @event.id
+      end
+
+      def event_type
+        @event.event_type
+      end
+
+      def key_hash
+        @event.key_hash
+      end
+
+      def key_string
+        @event.key_string || @event.key_hash.to_s
+      end
+
+      def byte_size
+        @event.byte_size
+      end
+
+      def human_byte_size
+        return nil unless @event.byte_size
+        ActiveSupport::NumberHelper.number_to_human_size(@event.byte_size)
+      end
+
+      def duration
+        @event.duration
+      end
+
+      def human_duration
+        return nil unless @event.duration
+        "#{(@event.duration * 1000).round(2)} ms"
+      end
+
+      def created_at
+        @event.created_at
+      end
+
+      def color
+        @event.color
+      end
+
+      def created_at_ago
+        time_ago_in_words(created_at)
+      end
+
+      private
+      
+      def time_ago_in_words(time)
+        distance_in_seconds = (Time.now - time).round
+        
+        case distance_in_seconds
+        when 0..59
+          "#{distance_in_seconds} seconds ago"
+        when 60..3599
+          "#{(distance_in_seconds / 60).round} minutes ago"
+        when 3600..86399
+          "#{(distance_in_seconds / 3600).round} hours ago"
+        else
+          "#{(distance_in_seconds / 86400).round} days ago"
+        end
+      end
+    end
+  end
+end

data/lib/solid_cache_dashboard/decorators/cache_events_decorator.rb

@@ -0,0 +1,44 @@
+module SolidCacheDashboard
+  module Decorators
+    class CacheEventsDecorator
+      include Enumerable
+
+      delegate :current_page, :total_pages, :limit_value, :total_count, :offset_value, to: :@events
+
+      def initialize(events)
+        @events = events
+      end
+
+      def each(&block)
+        @events.each do |event|
+          block.call(SolidCacheDashboard.decorate(event))
+        end
+      end
+
+      def hit_count
+        @hit_count ||= @events.hits.count
+      end
+
+      def miss_count
+        @miss_count ||= @events.misses.count
+      end
+
+      def write_count
+        @write_count ||= @events.writes.count
+      end
+
+      def delete_count
+        @delete_count ||= @events.deletes.count
+      end
+
+      def hit_ratio
+        return 0 if hit_count + miss_count == 0
+        hit_count.to_f / (hit_count + miss_count)
+      end
+
+      def hit_percentage
+        "#{(hit_ratio * 100).round(2)}%"
+      end
+    end
+  end
+end

data/lib/solid_cache_dashboard/engine.rb

@@ -0,0 +1,19 @@
+module SolidCacheDashboard
+  class Engine < ::Rails::Engine
+    isolate_namespace SolidCacheDashboard
+
+    initializer "solid_cache_dashboard.assets.precompile" do |app|
+      app.config.assets.precompile += %w[
+        solid_cache_dashboard/alpine.js
+        solid_cache_dashboard/application.js
+        solid_cache_dashboard/application.css
+      ]
+    end
+    
+    initializer "solid_cache_dashboard.instrumentation" do
+      config.after_initialize do
+        SolidCacheDashboard::Instrumentation.install
+      end
+    end
+  end
+end

data/lib/solid_cache_dashboard/instrumentation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module SolidCacheDashboard
+  module Instrumentation
+    def self.install
+      ActiveSupport::Notifications.subscribe("cache_read.active_support") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        key_hash = event.payload[:key].hash
+        key_string = event.payload[:key].to_s
+        hit = event.payload[:hit]
+        
+        SolidCacheDashboard::CacheEvent.create!(
+          event_type: hit ? SolidCacheDashboard::CacheEvent::HIT : SolidCacheDashboard::CacheEvent::MISS,
+          key_hash: key_hash,
+          key_string: key_string.truncate(100),
+          duration: event.duration / 1000.0, # Convert from ms to seconds
+          created_at: Time.current
+        )
+      end
+
+      ActiveSupport::Notifications.subscribe("cache_write.active_support") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        key_hash = event.payload[:key].hash
+        key_string = event.payload[:key].to_s
+
+        entry_size = nil
+        if event.payload[:entry]
+          entry_size = event.payload[:entry].bytesize
+        end
+        
+        SolidCacheDashboard::CacheEvent.create!(
+          event_type: SolidCacheDashboard::CacheEvent::WRITE,
+          key_hash: key_hash,
+          key_string: key_string.truncate(100),
+          byte_size: entry_size,
+          duration: event.duration / 1000.0, # Convert from ms to seconds
+          created_at: Time.current
+        )
+      end
+
+      ActiveSupport::Notifications.subscribe("cache_delete.active_support") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        key_hash = event.payload[:key].hash
+        key_string = event.payload[:key].to_s
+        
+        SolidCacheDashboard::CacheEvent.create!(
+          event_type: SolidCacheDashboard::CacheEvent::DELETE,
+          key_hash: key_hash,
+          key_string: key_string.truncate(100),
+          duration: event.duration / 1000.0, # Convert from ms to seconds
+          created_at: Time.current
+        )
+      end
+    end
+  end
+end

data/lib/solid_cache_dashboard/models/cache_event.rb

@@ -0,0 +1,51 @@
+module SolidCacheDashboard
+  class CacheEvent < ActiveRecord::Base
+    # Types of cache events
+    HIT = :hit
+    MISS = :miss
+    WRITE = :write
+    DELETE = :delete
+    
+    EVENT_TYPES = [HIT, MISS, WRITE, DELETE]
+    
+    EVENT_COLORS = {
+      HIT => "green",
+      MISS => "amber",
+      WRITE => "sky",
+      DELETE => "red"
+    }
+    
+    def self.event_color(event_type)
+      EVENT_COLORS[event_type] || "zinc"
+    end
+
+    self.table_name = 'solid_cache_dashboard_events'
+
+    scope :hits, -> { where(event_type: SolidCacheDashboard::CacheEvent::HIT) }
+    scope :misses, -> { where(event_type: SolidCacheDashboard::CacheEvent::MISS) }
+    scope :writes, -> { where(event_type: SolidCacheDashboard::CacheEvent::WRITE) }
+    scope :deletes, -> { where(event_type: SolidCacheDashboard::CacheEvent::DELETE) }
+    
+    scope :recent, -> { order(created_at: :desc) }
+
+    def hit?
+      event_type.to_sym == SolidCacheDashboard::CacheEvent::HIT
+    end
+
+    def miss?
+      event_type.to_sym == SolidCacheDashboard::CacheEvent::MISS
+    end
+
+    def write?
+      event_type.to_sym == SolidCacheDashboard::CacheEvent::WRITE
+    end
+
+    def delete?
+      event_type.to_sym == SolidCacheDashboard::CacheEvent::DELETE
+    end
+
+    def color
+      SolidCacheDashboard::CacheEvent.event_color(event_type.to_sym)
+    end
+  end
+end

data/lib/solid_cache_dashboard/version.rb

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

data/lib/solid_cache_dashboard.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rails"
+require "groupdate"
+require "chartkick"
+require_relative "solid_cache_dashboard/version"
+require_relative "solid_cache_dashboard/configuration"
+require_relative "solid_cache_dashboard/engine"
+require_relative "solid_cache_dashboard/cache_entry"
+# require_relative "solid_cache_dashboard/cache_event"
+require_relative "solid_cache_dashboard/instrumentation"
+require_relative "solid_cache_dashboard/models/cache_event"
+require_relative "solid_cache_dashboard/decorators/cache_entry_decorator"
+require_relative "solid_cache_dashboard/decorators/cache_entries_decorator"
+require_relative "solid_cache_dashboard/decorators/cache_event_decorator"
+require_relative "solid_cache_dashboard/decorators/cache_events_decorator"
+
+module SolidCacheDashboard
+  class Error < StandardError; end
+
+  def self.cache_keys
+    SolidCache::Entry.pluck(:key_hash).uniq
+  end
+
+  def self.decorate(object)
+    case object
+    when SolidCache::Entry
+      Decorators::CacheEntryDecorator.new(object)
+    when SolidCache::Entry.const_get(:ActiveRecord_Relation)
+      Decorators::CacheEntriesDecorator.new(object)
+    when SolidCacheDashboard::CacheEvent
+      Decorators::CacheEventDecorator.new(object)
+    when SolidCacheDashboard::CacheEvent.const_get(:ActiveRecord_Relation)
+      Decorators::CacheEventsDecorator.new(object)
+    else
+      raise Error, "Cannot decorate #{object.class}"
+    end
+  end
+end