Descrição

Pacote contendo as definições da Dead Letter Queue e o DeadLetterModule para auxiliar no tratamento das mensagens das filas do RabbitMQ

Pré-requisitos

• Definir globalmente o MongooseModule com a conexão ao banco de dados MongoDB
• Configurar um consumidor para a fila dead-letter (Dead Letter Queue) do RabbitMQ
• Configurar um produtor para a fila conectada à Dead Letter Queue (para que a DLQ possa enviar a mensagem de volta)

Instalação

yarn add @tegrus/dead-letter

Utilização

Ao configurar o consumidor da Dead Letter Queue (src/main.ts)

import { dlqConfig } from '@tegrus/dead-letter';

async function bootstrap() {
  // [...]

  const configService = app.get(ConfigService);

  app.connectMicroservice<MicroserviceOptions>(
    dlqConfig(configService.get<string>('rabbit.url')),
  );

  //[...]
}
bootstrap();

Ao configurar uma instância, tanto produtor quanto consumidor, de outra fila (as mensagens rejeitadas dessa fila serão enviadas para a Dead Letter Queue)

import { dlqBindConfig } from '@tegrus/dead-letter';

// [...]

ClientsModule.registerAsync([
  {
    name: 'MY_BROKER',
    useFactory: (configService: ConfigService) => ({
      transport: Transport.RMQ,
      options: {
        urls: [configService.get<string>('rabbit.url')],
        queue: 'myqueue',
        noAck: false,
        queueOptions: {
          durable: false,
          ...dlqBindConfig,
        },
      },
    }),
    inject: [ConfigService],
  },
]);

// [...]

Importar no módulo principal da aplicação

import { DeadLetterModule } from '@tegrus/dead-letter';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      cache: true,
      load: [myconfig],
    }),
    DeadLetterModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: (configService: ConfigService) => ({
        // A opção environment determina o ambiente de execução da aplicação
        environment: configService.get<string>('NODE_ENV'),
        // Uma lista de URLs para onde a mensagem rejeitada é enviada antes de ser descartada pela DLQ após exceder o limite de tentativas
        webhook: {
          urls: [configService.get<string>('webhookURL')],
        },
        // Caso a opção debug seja true, serão mostradas no console informações sobre as mensagens que são enviadas à DLQ
        debug: true,
      }),
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}

Utilizar o método run do DeadLetterService dentro dos métodos consumidores das filas

import { Controller, Inject } from '@nestjs/common';
import { ClientProxy, MessagePattern, RmqContext, Ctx } from '@nestjs/microservices';
import { DeadLetterService } from '@tegrus/dead-letter';

@Controller('my')
export class MyController {
  constructor(
    private readonly deadLetterService: DeadLetterService,
    @Inject('MY_BROKER') private readonly client: ClientProxy;
  ) {}

  @MessagePattern('pattern')
  async consumer(@Ctx() context: RmqContext) {
    await this.deadLetterService.run(context, this.client, async () => {
      // A lógica do consumer da sua fila
      // [...]
    })
  }
}

Desta forma a mensagem será recebida pela sua fila e executará a lógica que você implementou. Caso ocorra um erro durante o processamento da mensagem, ela será rejeitada e enviada para a DLQ, que por sua vez enviará de volta à fila original caso ainda não tenha atingido o limite de rententativas. Caso contrário, a messagem será enviada para o MongoDB.

Observações

• Não é necessário utilizar os métodos .ack e .reject/.nack no canal pois o DeadLetterService já faz isso