Forem: Suren Krmoian

Speed Up Your NestJS App with SWR Caching and RedisX

Suren Krmoian — Tue, 05 May 2026 10:00:26 +0000

Let's talk about something cool: Stale-While-Revalidate (SWR) caching. Imagine your app serves up slightly outdated data right away, while quietly updating it in the background. This means users get speedy responses without waiting for fresh data to load. Sweet, right? So, how do we get this running in a NestJS app? Meet RedisX.

Why Choose SWR?

Sometimes you need both speed and fresh data. SWR gives you that balance. Users get data fast, while your system updates in the background. Perfect for long data fetches, like big datasets or slow APIs.

Getting SWR Rolling with NestJS and RedisX

Ready to dive into setting up SWR? Here's how you can do it in a NestJS app using RedisX.

Step 1: Install Everything

First things first, install the necessary packages. Fire up your terminal:

npm install @nestjs-redisx/core @nestjs-redisx/cache

Step 2: Configure AppModule

Time to set up your AppModule. We'll hook in the Redis module and smuggle in the Cache plugin with SWR enabled. Use forRootAsync() to make the magic happen with NestJS's dependency injection.

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';
import { CachePlugin } from '@nestjs-redisx/cache';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        CachePlugin.registerAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: (config: ConfigService) => ({
            l1: { enabled: true, maxSize: 1000, ttl: 60 },
            defaultTtl: config.get('CACHE_TTL', 300),
            swr: { enabled: true, maxStale: 3600 },
          }),
        }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          type: 'single',
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
})
export class AppModule {}

Step 3: Use the @Cached Decorator

Here's where the magic happens. Use the @Cached decorator to slap caching onto your service methods. It'll let you define keys, TTLs, and SWR settings for each method.

import { Injectable } from '@nestjs/common';
import { Cached } from '@nestjs-redisx/cache';

@Injectable()
export class ProductService {
  @Cached({ key: 'product:{0}', ttl: 300, swr: { maxStale: 3600 } })
  async getProduct(id: string): Promise<Product> {
    return this.db.findProduct(id);
  }
}

In this setup, getProduct will serve stale data if it's there and refresh it in the background. Seamless for the user.

Why RedisX Rocks for SWR

RedisX makes SWR easy with its plugin system that uses just one Redis connection. Less overhead, more features. You get L1+L2 caching, tag-based invalidation, and more.

Performance Boost: Serve data instantly from the cache.
User Happiness: Less waiting for fresh data.
Simple Setup: Async support makes configuration a breeze.

Wrapping It Up

Setting up SWR in your NestJS app with RedisX is a breeze and super beneficial. Your apps stay fast and data stays fresh. Want to dive deeper? Check out the NestJS RedisX documentation.

By using RedisX, your NestJS apps don't just get faster—they become more robust and scalable. Redis magic at your fingertips.

Effortless Redis Sentinel Setup in NestJS with RedisX

Suren Krmoian — Tue, 21 Apr 2026 22:43:19 +0000

Redis Sentinel is no joke when it comes to keeping your Redis instances highly available. Hook it up with NestJS via RedisX, and you've got a streamlined, powerful setup.

Setting Up Redis Sentinel in NestJS with RedisX

Getting Redis Sentinel up and running with NestJS doesn't have to be rocket science. First, make sure your Redis environment has a Sentinel setup. You’ll need at least three Sentinel instances for a proper quorum and failover.

Step 1: Install Necessary Packages

Let's start by installing some packages. Open up your terminal and run:

npm install @nestjs-redisx/core ioredis

Boom. Now you have the core module and the ioredis driver, which plays nicely with Redis Sentinel.

Step 2: Sentinel Configuration

Time to configure. Head over to your AppModule in your NestJS app and set up RedisModule to use Sentinel:

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        clients: {
          type: 'sentinel',
          sentinels: [
            { host: config.get('SENTINEL_HOST1'), port: config.get('SENTINEL_PORT1') },
            { host: config.get('SENTINEL_HOST2'), port: config.get('SENTINEL_PORT2') },
            { host: config.get('SENTINEL_HOST3'), port: config.get('SENTINEL_PORT3') },
          ],
          name: config.get('SENTINEL_MASTER_NAME'),
        },
      }),
    }),
  ],
})
export class AppModule {}

Don’t forget to replace SENTINEL_HOST and SENTINEL_PORT with the actual details of your Sentinel instances.

Step 3: Why Use Redis Sentinel with RedisX?

Automatic Failover: If your master server bites the dust, Sentinel steps in, electing a new one without missing a beat.
Monitoring: Keeps an eye on your Redis instance. If something goes south, you'll know.
Simplified Setup: RedisX brings simplicity to Sentinel configurations, centralizing everything. Less hassle, more uptime.

RedisX Simplification

RedisX’s plugin architecture means everything—Sentinel included—lives under one roof. This keeps things neat, especially if you’re juggling multiple Redis setups.

Wrapping Up

There you have it. By setting up Redis Sentinel with NestJS via RedisX, you secure a reliable, high-availability Redis setup. It’s easy to manage and scales with your needs. Dive deeper into the NestJS RedisX documentation to explore more.

For specific details on configuring Redis Sentinel in NestJS, check out the NestJS Redis sentinel configuration.

NestJS RedisX: The Journey So Far

Suren Krmoian — Sat, 18 Apr 2026 09:08:48 +0000

NestJS RedisX: The Journey So Far

NestJS RedisX has been quite the story in the developer circles. Right from its launch, it’s been picking up steam on GitHub. Stars are rolling in, issues are being tackled head-on, and pull requests? They’re getting the attention they deserve. It’s like watching a community spring up around a new idea.

Why NestJS RedisX?

For those knee-deep in Redis and NestJS, NestJS RedisX is turning into a real game-changer. Handling enterprise-level challenges has never been more streamlined. The buzz and backing from the community? Honestly, it’s been a pleasant surprise. It’s this kind of energy that fuels us to keep improving.

What's Next?

We’ve got big plans. Our roadmap is packed with features and improvements that’ll push NestJS RedisX even further. The community’s energy is our battery pack, helping us find the time and resources to keep innovating.

How Can You Help?

Enjoying NestJS RedisX? Do us a favor and drop a star on GitHub. It’s a small gesture but means the world to us. It’s what keeps us going and helps us deliver even better solutions.

Become part of the movement. Contribute, lend a hand, and together, let’s shape the future of Redis tooling in NestJS. Every bit of support makes a difference.

Check it out on GitHub: nestjs-redisx/nestjs-redisx

NestJS RedisX: развитие и планы будущего

Suren Krmoian — Sat, 18 Apr 2026 09:06:05 +0000

Что нового в NestJS RedisX?

NestJS RedisX привлекает внимание разработчиков, и это не просто так. С момента запуска на GitHub проект набирает популярность: звёзды растут, проблемы решаются оперативно, а pull-реквесты активно рассматриваются и мёрджатся. Круто видеть, как формируется сообщество вокруг этого проекта!

Почему NestJS RedisX?

Для тех, кто углубляется в Redis и NestJS, RedisX становится незаменимым инструментом для решения задач на уровне предприятия. Положительные отзывы и поддержка сообщества просто поражают и вдохновляют на дальнейшую работу над улучшением инструментария.

Планы на будущее

У нас амбициозные планы: новые фичи и улучшения в пути. Энергия сообщества подстёгивает нас находить время и ресурсы для расширения возможностей NestJS RedisX.

Как вы можете помочь?

Если вам нравится использовать NestJS RedisX, поддержите нас звёздочкой на GitHub. Ваша поддержка бесценна и мотивирует нас создавать ещё более надёжные решения.

Присоединяйтесь, вносите свой вклад и помогите нам формировать будущее инструментов Redis в NestJS. Всякая поддержка важна, и вместе мы можем достичь многого.

Проверьте проект на GitHub: nestjs-redisx/nestjs-redisx

Mastering Rate Limiting in NestJS with RedisX

Suren Krmoian — Sun, 15 Mar 2026 10:00:17 +0000

Let's talk about something every API developer faces sooner or later: securing your endpoints without sacrificing performance. Rate limiting is a go-to strategy here. It's all about controlling the traffic load by limiting the number of requests a user can make in a set timeframe. If you're using NestJS, RedisX offers a nifty plugin to handle this with several strategies.

Rate Limiting Strategies Explained

Why so many strategies? Well, different scenarios call for different approaches.

Fixed Window: Think of it as the simplest approach. You reset the request count every fixed period, say a minute. Every new minute, users get a fresh quota. It's simple but not great with bursts of traffic.
Sliding Window: A bit more sophisticated. It considers requests over the last window duration, giving a smoother experience. This one's solid for most cases.
Token Bucket: If you're okay with some bursts, go for this. It lets tokens accumulate, and a request consumes a token. No tokens? No request. Simple.

Getting Started with NestJS RedisX

Alright, let's get this into your NestJS app. First things first, install the packages:

npm install @nestjs-redisx/core @nestjs-redisx/rate-limit

Then, configure your module. Use RateLimitPlugin.registerAsync for flexibility, especially if you're into dynamic configs:

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';
import { RateLimitPlugin, RateLimitGuard } from '@nestjs-redisx/rate-limit';
import { APP_GUARD } from '@nestjs/core';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        RateLimitPlugin.registerAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: (config: ConfigService) => ({
            defaultAlgorithm: config.get('RATE_LIMIT_ALGORITHM', 'sliding-window'),
            defaultPoints: config.get('RATE_LIMIT_POINTS', 100),
            defaultDuration: config.get('RATE_LIMIT_DURATION', 60),
          }),
        }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          type: 'single',
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
  providers: [
    { provide: APP_GUARD, useClass: RateLimitGuard },
  ],
})
export class AppModule {}

Limiting Specific Endpoints

Once set up, you can apply rate limits to your routes using the @RateLimit decorator. Great for public APIs:

import { Controller, Get } from '@nestjs/common';
import { RateLimit } from '@nestjs-redisx/rate-limit';

@Controller('api')
export class ApiController {
  @Get('data')
  @RateLimit({ points: 10, duration: 60 })
  getData() {
    return { data: 'rate limited endpoint' };
  }

  @Get('search')
  @RateLimit({ points: 5, duration: 60, key: 'ip' })
  search() {
    return { results: [] };
  }
}

Wrapping Up

Incorporating rate limiting can be a game-changer for your API's security and performance. With NestJS RedisX, you've got a powerful toolkit to do just that. Whether you're managing a bustling app or just want to keep things fair, RedisX has got your back. Dive deeper into the docs at nestjs-redisx.dev for more insights.

Keep It Synchronized: Distributed Locks in NestJS with RedisX

Suren Krmoian — Wed, 11 Mar 2026 10:00:24 +0000

Distributed locking can be a lifesaver when you're juggling multiple instances of an application. You know how it goes—everyone wants a piece of the pie, and without some rules, things get messy. Let’s talk about how to keep the peace with distributed locks in NestJS using RedisX. We'll focus on making sure those locks don't run out of steam and how to prevent deadlocks.

The Need for Distributed Locks

Imagine this: multiple instances of your app trying to update the same data at the same time. Chaos, right? Race conditions, data getting all tangled up, maybe even your system throwing a fit. Distributed locks are like the bouncers of your code, making sure only one instance gets through the door to that critical section at a time.

RedisX to the Rescue

NestJS RedisX is the toolkit you didn't know you needed for handling Redis in your app. It’s got this great @nestjs-redisx/locks package that makes setting up Redis-backed locks a breeze. Auto-renewal? Check. Deadlock prevention? Double check. These features are your safety net in a production environment.

Getting Started with RedisX Locks

First things first, you gotta install some packages:

npm install @nestjs-redisx/core @nestjs-redisx/locks

Next up, configure your Redis module in AppModule like so:

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';
import { LocksPlugin } from '@nestjs-redisx/locks';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        LocksPlugin.registerAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: (config: ConfigService) => ({
            defaultTtl: config.get('LOCK_DEFAULT_TTL', 30000),
            retry: {
              maxRetries: config.get('LOCK_MAX_RETRIES', 3),
              initialDelay: config.get('LOCK_RETRY_DELAY', 100),
            },
            autoRenew: { enabled: config.get('LOCK_AUTO_RENEW', true) },
          }),
        }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          type: 'single',
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
})
export class AppModule {}

Using Locks in Your Services

Now, let's put those locks to work. With RedisX set up, you can use the @WithLock decorator to handle locks around your service methods. It does the heavy lifting of acquiring and releasing locks for you.

import { Injectable } from '@nestjs/common';
import { WithLock } from '@nestjs-redisx/locks';

@Injectable()
export class PaymentService {
  @WithLock({ key: 'payment:{0}', ttl: 10000 })
  async processPayment(orderId: string): Promise<Payment> {
    const order = await this.orderRepository.findById(orderId);
    if (order.status === 'paid') {
      throw new PaymentAlreadyProcessedError(orderId);
    }
    const result = await this.paymentGateway.charge(order);
    await this.orderRepository.update(orderId, { status: 'paid' });
    return result;
  }
}

Keeping It Smooth with Auto-Renewal and Deadlocks

RedisX’s lock plugin is smart about keeping locks alive during long operations. Auto-renewal extends the lock's TTL as needed. Plus, if something goes wrong and the lock-holder crashes, deadlock prevention ensures the lock will eventually expire, letting others have a go.

Wrapping It Up

Using RedisX for distributed locking in NestJS not only makes life easier but also boosts your system's reliability. You get to focus on the fun parts of building, while RedisX takes care of the nitty-gritty of keeping things in order. Happy coding!

NestJS RedisX Joins the Awesome NestJS List!

Suren Krmoian — Wed, 11 Mar 2026 01:26:33 +0000

Boom! Big news in the NestJS world. NestJS RedisX just snagged a spot on the Awesome NestJS list. Yep, it's that cool.

So, What’s Awesome NestJS Anyway?

Think of Awesome NestJS as the ultimate toolkit. It's a handpicked collection of resources, libraries, and tools that make building apps with NestJS a breeze. Getting on this list? It’s a nod to our project’s quality and value to devs everywhere.

Why All the Buzz About NestJS RedisX?

NestJS RedisX isn’t just another tool. It’s a powerhouse for Redis in the NestJS ecosystem. Imagine handling caching, distributed locks, rate limiting, streams, and more—all with one Redis connection. That’s what our modular plugin architecture does. Perfect for when you’re building something that needs to work, and work well.

Go See For Yourself

Curious about what makes us tick? We’re on the Awesome NestJS list right here. This recognition fuels our drive to keep delivering solid stuff for the NestJS crowd.

A massive thank you to everyone who’s backed us. Your feedback? It’s gold. Seriously.

Keep in Touch

Want the full scoop? Dive into our documentation or check out our GitHub repo. We’re all about hearing from you, so bring on the thoughts and ideas.

Thanks for being part of our adventure!

Boosting Performance with Two-Tier Caching in NestJS

Suren Krmoian — Tue, 03 Mar 2026 10:00:38 +0000

Boosting Performance with Two-Tier Caching in NestJS

Let's cut right to the chase. If you're building web applications with NestJS, you know performance and scalability are non-negotiable. One way to keep things zippy is by using a two-tier caching strategy. That's where NestJS RedisX comes into play. It's an open-source toolkit that simplifies Redis integration in NestJS apps, making it ridiculously easy to set up a two-layer cache. Let's get our hands dirty with some code and see how you can implement this.

What's Two-Tier Caching Anyway?

Alright, so you've got two levels of caching here. The first level (L1) is your in-memory cache. It's right there on the server with your application, super fast, low latency. But, of course, it's limited by your server's memory.

Then there's the second level (L2), which is a Redis-based cache. This one lives across the network, can store a ton more data, and is shared across multiple instances. So, if L1 doesn't have what you're looking for, L2 steps in before you have to hit the database. Pretty neat, right?

Setting It Up with NestJS RedisX

Now, let's dive into the implementation. With RedisX, setting up this cache is a breeze. Follow these steps to get it rolling.

Step 1: Get the Packages

First things first, you need to install the necessary RedisX packages. Pop open your terminal and run:

npm install @nestjs-redisx/core @nestjs-redisx/cache

Step 2: Configure the Redis Module

Next, you'll want to configure the RedisModule in your AppModule. This is where the magic starts:

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';
import { CachePlugin } from '@nestjs-redisx/cache';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        CachePlugin.registerAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: (config: ConfigService) => ({
            l1: { enabled: true, maxSize: 1000, ttl: 60 },
            defaultTtl: config.get('CACHE_TTL', 300),
          }),
        }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          type: 'single',
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
})
export class AppModule {}

Step 3: Use Caching in Your Services

Now, let's put that cache to work. Use the @Cached decorator in your services. It'll check the L1 cache first, then L2, and update both as needed:

import { Injectable } from '@nestjs/common';
import { Cached } from '@nestjs-redisx/cache';

@Injectable()
export class ProductService {
  @Cached({ key: 'product:{0}', ttl: 3600 })
  async getProduct(id: string) {
    return this.db.findProduct(id);
  }
}

Why Bother with Two-Tier Caching?

Speed: L1 cache is lightning fast, reducing latency to virtually nothing.
Scalability: L2 lets you handle big datasets and share that cached goodness across instances.
Efficiency: RedisX’s plugin-based setup is smooth and reduces the load on your database, keeping your app peppy.

Wrapping It Up

There you have it. A two-tier caching system using NestJS RedisX. It's a solid strategy to keep your app running smoothly even under heavy loads. For a deeper dive and more configuration options, check out the NestJS RedisX documentation.

Level Up Your NestJS App with RedisX

Suren Krmoian — Sun, 01 Mar 2026 10:00:28 +0000

Level Up Your NestJS App with RedisX

Diving into Redis with NestJS? Many of us start with ioredis for basic operations. But as your app grows, things get hairy. Caching, distributed locks, observability—suddenly, the simple setup isn't cutting it. This is where NestJS RedisX steps in. It's a toolkit that wraps up all those extra Redis features you need, neatly integrated into the NestJS framework.

What's Wrong with Just ioredis?

Honestly, nothing. If you're okay with juggling Redis connections, manual caching, and everything else by yourself. But let's face it, as projects scale, this manual handling turns into a maintenance nightmare. RedisX takes away that pain by offering a streamlined API that's baked right into NestJS. Less hassle, more productivity.

Getting Started with RedisX

Step 1: Install the Essentials

First things first, let's get RedisX into your project. Focus on the core package and the plugins you need. We'll deal with caching and locks here:

npm install @nestjs-redisx/core @nestjs-redisx/cache @nestjs-redisx/locks

Step 2: Set Up the Redis Module

Time to swap out your old ioredis setup. Configure the RedisModule in your AppModule like this:

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';
import { CachePlugin } from '@nestjs-redisx/cache';
import { LocksPlugin } from '@nestjs-redisx/locks';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        CachePlugin.registerAsync({
          inject: [ConfigService],
          useFactory: (config: ConfigService) => ({
            defaultTtl: config.get('CACHE_TTL', 300),
          }),
        }),
        new LocksPlugin({ retryAttempts: 3 }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          type: 'single',
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
})
export class AppModule {}

Step 3: Transform Your Service Logic

Change your cache logic from ioredis commands to RedisX decorators. Here's a quick switch:

Before (ioredis):

async getUser(id: string): Promise<User> {
  const cached = await this.redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);
  const user = await this.userRepository.findById(id);
  await this.redis.setex(`user:${id}`, 3600, JSON.stringify(user));
  return user;
}

After (RedisX):

import { Injectable } from '@nestjs/common';
import { Cached } from '@nestjs-redisx/cache';

@Injectable()
export class UserService {
  @Cached({ key: 'user:{0}', ttl: 3600 })
  async getUser(id: string): Promise<User> {
    return this.userRepository.findById(id);
  }
}

Step 4: Handling Distributed Locks

Ditch the manual lock logic. Use RedisX's @WithLock decorator for a cleaner and safer approach.

Before (ioredis):

const lock = await this.redis.set(lockKey, uuid(), 'EX', 30, 'NX');
if (!lock) throw new Error('Lock acquisition failed');
try { await this.doWork(); }
finally { await this.redis.del(lockKey); }

After (RedisX):

import { WithLock } from '@nestjs-redisx/locks';

@WithLock({ key: 'resource:{0}', ttl: 5000 })
async secureResourceAccess(resourceId: string) {
  await this.doWork(resourceId);
}

Why Make the Switch?

RedisX isn't just a nice-to-have. It's packed with advanced features like L1+L2 caching, distributed locks, and more—all under one roof. Your codebase becomes cleaner, less error-prone, and ready for scale. Dive into the official docs for more.

Ready to take your NestJS app to the next level? RedisX is your friend. Give it a go.

Boost Your NestJS Observability with RedisX

Suren Krmoian — Fri, 27 Feb 2026 10:00:41 +0000

Observability is one of those things you can't ignore if you're managing modern applications. It's the secret sauce that gives developers a peek into how their systems are really performing. If you're working with NestJS and Redis, the RedisX toolkit is your new best friend for upping your observability game with Prometheus metrics and OpenTelemetry tracing.

Getting RedisX Rolling in Your NestJS App

Let's get down to business and set up RedisX for some serious observability in your NestJS app. First things first, you'll need to install a few packages. Fire up your terminal and run:

npm install @nestjs-redisx/core @nestjs-redisx/metrics @nestjs-redisx/tracing

Once that's sorted, it's time to tweak your AppModule. You'll want to add MetricsPlugin and TracingPlugin to get Prometheus metrics and OpenTelemetry tracing without breaking a sweat.

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';
import { MetricsPlugin } from '@nestjs-redisx/metrics';
import { TracingPlugin } from '@nestjs-redisx/tracing';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        new MetricsPlugin({ enabled: true, exposeEndpoint: true }),
        new TracingPlugin({ serviceName: 'nestjs-app' }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          type: 'single',
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
})
export class AppModule {}

Prometheus Metrics: The Lowdown

With MetricsPlugin in place, your app now has a /metrics endpoint ready to roll. This little endpoint is a goldmine of info on Redis operations—think cache hits, misses, and lock contentions.

If you're using Prometheus, you need to set it up to scrape this endpoint. Your prometheus.yml should look something like this:

global:
  scrape_interval: 15s
scrape_configs:
  - job_name: 'nestjs-app'
    metrics_path: '/metrics'
    static_configs:
      - targets: ['localhost:3000']

OpenTelemetry Tracing: Going Deeper

TracingPlugin in RedisX uses OpenTelemetry to keep track of every Redis operation. It's like having a magnifying glass on every command—great for spotting performance bottlenecks.

Here's a quick example of how you might use custom spans in a NestJS service:

import { Injectable, Inject } from '@nestjs/common';
import { TRACING_SERVICE, ITracingService } from '@nestjs-redisx/tracing';

@Injectable()
export class UserService {
  constructor(@Inject(TRACING_SERVICE) private readonly tracing: ITracingService) {}

  async getUser(id: string): Promise<unknown> {
    return this.tracing.withSpan('user.get', async () => {
      this.tracing.setAttribute('user.id', id);
      const user = await this.userRepo.findById(id);
      this.tracing.addEvent('user.found', { 'user.email': user.email });
      return user;
    });
  }
}

Wrapping It Up

By bringing RedisX’s MetricsPlugin and TracingPlugin into your NestJS workflow, you're not just monitoring your app—you're setting it up for success. These tools give you the insights you need to keep things running smoothly and fix issues before they become problems.

Want more details on RedisX plugins? Check out the RedisX documentation.

Taming Cache Stampede in NestJS with RedisX

Suren Krmoian — Mon, 23 Feb 2026 10:00:31 +0000

Taming Cache Stampede in NestJS with RedisX

Cache stampede, or the thundering herd problem, is that pesky issue when a cache expires, and suddenly, your database gets bombarded by a swarm of requests. Not fun. In NestJS, there's a nifty way to tackle this using NestJS RedisX.

What's the Deal with Cache Stampede?

Imagine this: your app’s cache entry expires. Every request that comes in wants to hit the database at the same time. Chaos, right? The trick here is to make sure only one request actually goes through to the database, and the rest just chill until the first request updates the cache.

Enter NestJS RedisX

NestJS RedisX is like a Swiss Army knife for Redis in NestJS. One of its coolest features? Built-in cache stampede protection.

Setting It Up

Let's see how to set this up and save your database from overload.

Get the Packages First thing, install RedisX and the cache plugin:

   npm install @nestjs-redisx/core @nestjs-redisx/cache

Configure Redis in Your AppModule Use RedisModule.forRootAsync to set things up with async config (thanks to ConfigService):

   import { Module } from '@nestjs/common';
   import { ConfigModule, ConfigService } from '@nestjs/config';
   import { RedisModule } from '@nestjs-redisx/core';
   import { CachePlugin } from '@nestjs-redisx/cache';

   @Module({
     imports: [
       ConfigModule.forRoot({ isGlobal: true }),
       RedisModule.forRootAsync({
         imports: [ConfigModule],
         inject: [ConfigService],
         plugins: [
           CachePlugin.registerAsync({
             inject: [ConfigService],
             useFactory: (config: ConfigService) => ({
               l1: { enabled: true, maxSize: 1000, ttl: 60 },
               defaultTtl: config.get('CACHE_TTL', 300),
               stampede: { enabled: true },
             }),
           }),
         ],
         useFactory: (config: ConfigService) => ({
           clients: {
             host: config.get('REDIS_HOST', 'localhost'),
             port: config.get('REDIS_PORT', 6379),
           },
         }),
       }),
     ],
   })
   export class AppModule {}

Decorate Your Services with @Cached Now, slap the @Cached decorator on your service methods that fetch data:

   import { Injectable } from '@nestjs/common';
   import { Cached } from '@nestjs-redisx/cache';

   @Injectable()
   export class ProductService {
     @Cached({ key: 'product:{0}', ttl: 3600, stampede: { enabled: true } })
     async getProduct(id: string): Promise<Product> {
       return this.db.findProduct(id);
     }
   }

The Magic Behind It

With the @Cached decorator and the stampede option enabled, your app ensures that only one request hits the database. The rest wait their turn, and everyone gets their data once the cache is updated. It’s like a well-behaved queue at the supermarket checkout.

NestJS RedisX doesn't just handle cache stampedes. It's a full-on toolkit integrating Redis with features like distributed locks, rate limiting, and observability tools. Dive deeper into the official docs or check out the GitHub repo for more.

Redis in NestJS: The RedisX Solution You Didn't Know You Needed

Suren Krmoian — Sun, 22 Feb 2026 22:34:35 +0000

Redis in NestJS: The RedisX Solution You Didn't Know You Needed

Tired of wrangling with multiple libraries for Redis operations in your NestJS app? Meet NestJS RedisX. It’s the all-in-one toolkit for all your Redis needs — caching, locking, rate limiting, and more — without the hassle of multiple connections.

Why RedisX?

If you've been struggling with managing separate Redis connections for different functions, RedisX is your new best friend. It offers a modular approach where everything runs off a single Redis connection. That means less complexity and centralized configuration.

Plugin Power

RedisX is all about plugins. Install just what you need and keep things lean:

@nestjs-redisx/cache: L1+L2 caching with some nifty features like stampede protection.
@nestjs-redisx/locks: Distributed locks with auto-renewal.
@nestjs-redisx/rate-limit: Various strategies for rate limiting.
@nestjs-redisx/idempotency: Keep those requests idempotent.
@nestjs-redisx/streams: For those who love event-driven architectures.
@nestjs-redisx/metrics: Prometheus metrics, anyone?
@nestjs-redisx/tracing: OpenTelemetry tracing support.

Get Up and Running

Ready to dive in? Install the core package and any plugins you fancy:

npm install @nestjs-redisx/core @nestjs-redisx/cache @nestjs-redisx/locks

Then, wire it up in your AppModule:

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';
import { CachePlugin } from '@nestjs-redisx/cache';
import { LocksPlugin } from '@nestjs-redisx/locks';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        CachePlugin.registerAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: (config: ConfigService) => ({
            l1: { enabled: true, maxSize: 1000, ttl: 60 },
            defaultTtl: config.get('CACHE_TTL', 300),
          }),
        }),
        new LocksPlugin({ retryAttempts: 3, retryDelay: 200 }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          type: 'single',
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
})
export class AppModule {}

Wrapping It Up

RedisX is the toolkit that makes Redis integration a breeze in NestJS applications. No more juggling — just a clean, unified approach to Redis. Focus more on what you love: building cool features. For more insights, check out the official documentation and GitHub repository.