ruby 27 lines · 1 tab

Redis caching for expensive computations

Alex Kumar Jan 2026

1 tab

class TrendingPostsService
  CACHE_KEY = 'trending_posts:v1'.freeze
  CACHE_TTL = 15.minutes

  def self.call(limit: 10)
    Rails.cache.fetch(CACHE_KEY, expires_in: CACHE_TTL) do
      compute_trending_posts(limit)
    end
  end

  def self.compute_trending_posts(limit)
    # Expensive calculation combining views, likes, recency
    Post.published
        .where('created_at >= ?', 7.days.ago)
        .select('posts.*,
                (LOG(posts.views + 1) * 0.5 +
                 LOG(posts.likes_count + 1) * 0.3 +
                 (EXTRACT(EPOCH FROM posts.created_at) / 100000) * 0.2) AS trending_score')
        .order('trending_score DESC')
        .limit(limit)
        .to_a
  end

  def self.clear_cache
    Rails.cache.delete(CACHE_KEY)
  end
end

1 file · ruby Explain with highlit

Redis provides a fast, in-memory cache for expensive computations that don't change frequently. I use Rails.cache with the Redis store to cache things like trending posts calculations, aggregated statistics, or external API responses. The fetch method handles read-through caching elegantly: it returns the cached value if present, otherwise executes the block and stores the result. Proper cache key design is critical—I include version identifiers and relevant parameters so updates invalidate correctly. The expires_in option sets TTL to prevent stale data from accumulating. For high-traffic apps, I sometimes cache partially rendered views or serialized JSON, though I'm careful to invalidate when underlying data changes.

Related snips

ruby

class CommentsController < ApplicationController
  before_action :set_post

  def create
    @comment = @post.comments.build(comment_params)

System test: asserting Turbo Stream responses

rails hotwire turbo

by codesnips 4 tabs

ruby

class Post < ApplicationRecord
  belongs_to :author, class_name: 'User'
  has_many :comments, dependent: :destroy

  scope :published, -> { where.not(published_at: nil).where('published_at <= ?', Time.current) }
  scope :draft, -> { where(published_at: nil) }

ActiveRecord scopes for reusable query logic

rails activerecord patterns

by Alex Kumar 1 tab

ruby

module Api
  module V1
    class UsersController < BaseController
      def show
        user = User.includes(:profile).find(params[:id])

ETags for conditional requests and caching

rails caching http-caching

by Alex Kumar 1 tab

ruby

class PostsController < ApplicationController
  def index
    @posts = Post.includes(:author)
                 .order(created_at: :desc)
                 .page(params[:page])
                 .per(10)

Turbo Frames: infinite scroll with lazy-loading frame

rails turbo hotwire

by codesnips 4 tabs

ruby

require "csv"

class PeopleCsvStream
  include Enumerable

  HEADERS = %w[id full_name email signed_up_at plan].freeze

Resilient CSV Export as a Streamed Response

rails performance streaming

by codesnips 3 tabs

erb

<form data-controller="query-sync" data-action="change->query-sync#apply">
  <select name="status" class="rounded border p-2">
    <option value="">Any</option>
    <option value="open">Open</option>
    <option value="closed">Closed</option>
  </select>

Filter UI that syncs query params via Stimulus (no front-end router)

rails hotwire stimulus

by Henry Kim 2 tabs

Share this code

Here's the card — post it anywhere.

Redis caching for expensive computations — share card

Link copied