Forem: Suren Krmoian

Mastering Redis Streams and DLQ in NestJS with RedisX

Suren Krmoian — Fri, 22 May 2026 07:05:15 +0000

Using Redis Streams in NestJS RedisX can be a game changer for anyone building event-driven systems. Today, let's dig into consumer groups and dead letter queues (DLQ) — two features that can really up your game in creating resilient architectures.

Redis Streams: The Basics

Redis Streams let you handle messages in a scalable way. The cool part? With consumer groups, you can have multiple service instances share the workload. So, each message goes to just one instance in the group. Perfect for load balancing and keeping your services running smoothly.

Getting Hands-On with Consumer Groups

Let's look at how easy it is to set up a consumer group in NestJS RedisX. With the @StreamConsumer decorator, you can define a consumer that listens to a specific stream and group:

import { Injectable } from '@nestjs/common';
import { StreamConsumer, IStreamMessage } from '@nestjs-redisx/streams';

@Injectable()
export class OrderProcessor {
  @StreamConsumer({
    stream: 'orders',
    group: 'order-processors',
    batchSize: 10,
  })
  async handleOrder(message: IStreamMessage<OrderEvent>): Promise<void> {
    const { orderId } = message.data;
    try {
      await this.fulfillmentService.process(orderId);
      await message.ack();
    } catch (error) {
      await message.reject(error);
    }
  }
}

Tackling Dead Letter Queues (DLQ)

Now, let's talk about DLQs. They're essential for dealing with message failures. If a message can't be processed after a few tries, you don't want it disappearing into the void. A DLQ ensures these messages are stored for review later — crucial for troubleshooting and making sure nothing slips through the cracks.

Here's how easy it is to enable DLQ in NestJS RedisX:

new StreamsPlugin({
  consumer: { batchSize: 10, maxRetries: 3 },
  dlq: { enabled: true },
})

Building Resilient Systems

With Redis Streams, consumer groups, and DLQ, you're well on your way to building systems that are both scalable and fault-tolerant. RedisX takes care of the heavy lifting, letting you zero in on your business logic.

For those hungry for more, it might be worth checking how these patterns play with other RedisX goodies like caching, idempotency, and tracing. All these pieces fit together to form a robust event-driven architecture.

Dive into the documentation for deeper insights on configuration and advanced usage. Want more? Check out our previous posts on Redis Sentinel and Cache Isolation for tips on building scalable applications with RedisX. nestjs redis streams

Implementing Idempotency with NestJS RedisX: A Practical Guide

Suren Krmoian — Tue, 12 May 2026 10:00:19 +0000

Handling duplicate requests in APIs, especially in payment systems, is a headache. NestJS RedisX offers a neat way to tackle this with its Idempotency Plugin. Let’s dig into how you can set this up.

Getting Started with Idempotency

First things first, install the necessary packages. You'll need both the core and idempotency packages of NestJS RedisX:

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

Configuring the Module

To make the Idempotency Plugin work its magic, you need to configure it in your main module. This setup ensures that the plugin is ready to catch any duplicate requests globally.

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

@Module({
  imports: [
    ConfigModule.forRoot(),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        IdempotencyPlugin.registerAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: (config: ConfigService) => ({
            defaultTtl: 86400, // 24 hours
            headerName: 'Idempotency-Key',
          }),
        }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
  providers: [
    { provide: APP_INTERCEPTOR, useClass: IdempotencyInterceptor },
  ],
})
export class AppModule {}

Decorating Your Endpoints

Once your module is good to go, use the @Idempotent decorator on your endpoints. This ensures that each request is uniquely processed based on the Idempotency-Key.

import { Controller, Post, Body } from '@nestjs/common';
import { Idempotent } from '@nestjs-redisx/idempotency';

@Controller('payments')
export class PaymentsController {
  constructor(private readonly paymentService: PaymentService) {}

  @Post()
  @Idempotent()
  async createPayment(@Body() dto: CreatePaymentDto) {
    return this.paymentService.process(dto);
  }
}

Behind the Scenes

Here’s the lowdown: the Idempotency Plugin checks each request’s Idempotency-Key. If it’s seen the key before, it serves the cached result. No re-processing, no fuss.

Body Fingerprinting: It goes a step further by ensuring the request body’s fingerprint matches the key. This prevents using the same key for different data.
Concurrent Handling: If multiple requests with the same key pop up, the plugin handles them in sequence, avoiding any duplication.

Incorporating an idempotency layer using NestJS RedisX is pretty straightforward. It's a solid way to dodge duplicate processing in sensitive areas like payments. Want to dive deeper? Check out the official documentation.

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.