rxjs-rabbitmq 2.1.9 → 2.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -29,7 +29,9 @@ import {
29
29
  } from "rxjs";
30
30
 
31
31
  import {
32
+ getSerializer,
32
33
  mapify,
34
+ registerSerializer,
33
35
  SERIALIZERS,
34
36
  uniqueValue,
35
37
  wait
@@ -39,6 +41,7 @@ import {
39
41
  MapType,
40
42
  QueueExchangeBindingConfig,
41
43
  RabbitMqInitConfig,
44
+ RabbitMqLogger,
42
45
  RmqEventHandler,
43
46
  RmqEventMessage,
44
47
  RmqHandleMessageTypeConfig,
@@ -60,6 +63,7 @@ export type RmgOnEventHandler = (event: RmqEventMessage, rmqClient?: RabbitMQCli
60
63
  */
61
64
  export class RabbitMQClient {
62
65
  private clientInitConfig: RabbitMqInitConfig;
66
+ private logger: RabbitMqLogger;
63
67
 
64
68
  private connection: Connection;
65
69
  private channel: Channel;
@@ -67,6 +71,8 @@ export class RabbitMQClient {
67
71
  private isReadyStream: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(this.isReady);
68
72
  private connectionErrorStream: Subject<any> = new Subject<any>();
69
73
  private connectionCloseStream: Subject<any> = new Subject<any>();
74
+ private reconnectTimeout: ReturnType<typeof setTimeout> | undefined;
75
+ private reconnectAttempts: number = 0;
70
76
 
71
77
  /*
72
78
  Handle all messages from all queues on this client
@@ -80,13 +86,35 @@ export class RabbitMQClient {
80
86
 
81
87
  private DEFAULT_LISTENER_TYPE: string = '__default';
82
88
  private queueListeners: MapType<Subscription> = {};
89
+ private registeredQueueConsumers: Array<{ queue: string, options?: Options.Consume }> = [];
90
+ private metricsEnabled: boolean;
91
+ private metrics: {
92
+ messagesReceived: number;
93
+ messagesPublished: number;
94
+ messagesAcked: number;
95
+ messagesNacked: number;
96
+ messagesRetried: number;
97
+ rpcRequests: number;
98
+ rpcResponses: number;
99
+ reconnects: number;
100
+ } = {
101
+ messagesReceived: 0,
102
+ messagesPublished: 0,
103
+ messagesAcked: 0,
104
+ messagesNacked: 0,
105
+ messagesRetried: 0,
106
+ rpcRequests: 0,
107
+ rpcResponses: 0,
108
+ reconnects: 0,
109
+ };
83
110
 
84
- private queueToEventHandleMapping: MapType<
85
- MapType<ReplaySubject<RmqEventMessage>>
86
- > = {};
87
- private queueToEventCallbackMapping: MapType<
88
- MapType<RmqMessageTypeHandler>
89
- > = {};
111
+ private queueToEventHandleMapping: Map<string, Map<string, ReplaySubject<RmqEventMessage>>> = new Map();
112
+ private queueToEventCallbackMapping: Map<string, Map<string, RmqMessageTypeHandler>> = new Map();
113
+
114
+ private log(level: keyof RabbitMqLogger, ...args: unknown[]) {
115
+ const handler = this.logger[level] || (() => undefined);
116
+ handler(...args);
117
+ }
90
118
 
91
119
  get onReady(): Observable<boolean> {
92
120
  return this.isReadyStream.asObservable().pipe(
@@ -109,13 +137,65 @@ export class RabbitMQClient {
109
137
 
110
138
  constructor(clientInitConfig: RabbitMqInitConfig) {
111
139
  this.clientInitConfig = clientInitConfig;
140
+ this.metricsEnabled = !!clientInitConfig.metrics;
141
+ this.logger = {
142
+ debug: clientInitConfig.logger?.debug ?? (() => undefined),
143
+ info: clientInitConfig.logger?.info ?? console.info.bind(console),
144
+ warn: clientInitConfig.logger?.warn ?? console.warn.bind(console),
145
+ error: clientInitConfig.logger?.error ?? console.error.bind(console),
146
+ };
112
147
  !clientInitConfig.stopAutoInit && this.init();
113
148
  }
114
149
 
150
+ static registerSerializer(contentType: string, serializer: { serialize: (value: unknown) => Buffer; deserialize: (value: Buffer, encoding?: BufferEncoding) => unknown }) {
151
+ return registerSerializer(contentType, serializer);
152
+ }
153
+
154
+ getMetrics() {
155
+ return { ...this.metrics };
156
+ }
157
+
158
+ private resubscribeToRegisteredQueues() {
159
+ for (const { queue, options } of this.registeredQueueConsumers) {
160
+ if (this.queueListeners[queue]) {
161
+ this.queueListeners[queue].unsubscribe();
162
+ delete this.queueListeners[queue];
163
+ }
164
+ this.listenToQueue(queue, options);
165
+ }
166
+ }
167
+
168
+ private scheduleReconnect(reason: string) {
169
+ if (this.reconnectTimeout) {
170
+ return;
171
+ }
172
+
173
+ const retryAttempts = this.clientInitConfig.retryAttempts || 0;
174
+ if (retryAttempts > 0 && this.reconnectAttempts >= retryAttempts) {
175
+ this.log('error', `RabbitMQ reconnect attempts exhausted after ${retryAttempts} tries.`);
176
+ return;
177
+ }
178
+
179
+ this.isReady = false;
180
+ this.isReadyStream.next(false);
181
+ this.reconnectAttempts += 1;
182
+ this.metrics.reconnects += 1;
183
+ const retryDelay = this.clientInitConfig.retryDelay || 1000;
184
+
185
+ this.log('warn', `${reason}; reconnecting in ${retryDelay}ms (attempt ${this.reconnectAttempts}/${retryAttempts || '∞'})`);
186
+
187
+ this.reconnectTimeout = setTimeout(() => {
188
+ this.reconnectTimeout = undefined;
189
+ this.init().catch((error) => {
190
+ this.log('error', 'Reconnect failed', error);
191
+ });
192
+ }, retryDelay);
193
+ }
194
+
115
195
  init() {
116
196
  if (this.isReady) {
117
- console.log(`Already initialized`);
118
- return;
197
+ this.log('info', 'Already initialized');
198
+ return Promise.resolve();
119
199
  }
120
200
  const {
121
201
  delayStart,
@@ -133,11 +213,11 @@ export class RabbitMQClient {
133
213
 
134
214
  const init: () => Promise<any> = () => {
135
215
  // creating connection
136
- console.log(`Attempting connection to Rabbit MQ...`);
216
+ this.log('info', 'Attempting connection to Rabbit MQ...');
137
217
  return connect(connection_url)
138
218
  .then((connection) => {
139
219
  this.connection = connection;
140
- console.log(`Connected to message server`);
220
+ this.log('info', 'Connected to message server');
141
221
  return this.connection.createChannel();
142
222
  })
143
223
  // creating channel
@@ -146,30 +226,29 @@ export class RabbitMQClient {
146
226
  if (prefetch) {
147
227
  this.channel.prefetch(prefetch || 1);
148
228
  }
149
- console.log(`Channel created on message server`);
229
+ this.log('info', 'Channel created on message server');
150
230
  })
151
231
  // assert to queues
152
232
  .then(() => {
153
233
  const promises: Promise<Replies.AssertQueue>[] = [];
154
234
 
155
235
  for (const queueConfig of queues) {
156
- this.queueToEventHandleMapping[queueConfig.name] = {};
157
- this.queueToEventCallbackMapping[queueConfig.name] = {};
158
-
159
- const queueListenersMap = this.queueToEventHandleMapping[queueConfig.name];
160
- const queueCallbacksMap = this.queueToEventCallbackMapping[queueConfig.name];
236
+ const queueListenersMap = new Map<string, ReplaySubject<RmqEventMessage>>();
237
+ const queueCallbacksMap = new Map<string, RmqMessageTypeHandler>();
238
+ this.queueToEventHandleMapping.set(queueConfig.name, queueListenersMap);
239
+ this.queueToEventCallbackMapping.set(queueConfig.name, queueCallbacksMap);
161
240
 
162
241
  // by default, create an observable stream on the queue for unidentified/null routing keys
163
- queueListenersMap[this.DEFAULT_LISTENER_TYPE] = new ReplaySubject();
242
+ queueListenersMap.set(this.DEFAULT_LISTENER_TYPE, new ReplaySubject());
164
243
 
165
244
  const useHandleMessageTypes: RmqHandleMessageTypeConfigs = queueConfig.handleMessageTypes || [];
166
245
  for (const messageType of useHandleMessageTypes) {
167
246
  if (typeof messageType === 'string') {
168
- queueListenersMap[messageType as string] = new ReplaySubject();
247
+ queueListenersMap.set(messageType as string, new ReplaySubject());
169
248
  }
170
249
  else {
171
250
  const config: RmqHandleMessageTypeConfig = messageType;
172
- queueCallbacksMap[config.messageName] = config.callbackHandler;
251
+ queueCallbacksMap.set(config.messageName, config.callbackHandler);
173
252
  }
174
253
  }
175
254
 
@@ -178,7 +257,7 @@ export class RabbitMQClient {
178
257
 
179
258
  return Promise.all(promises).then((values) => {
180
259
  this.queues = mapify(values, 'queue');
181
- console.log(`queues created on channel`);
260
+ this.log('info', 'queues created on channel');
182
261
  });
183
262
  })
184
263
  // assert exchanges
@@ -186,7 +265,7 @@ export class RabbitMQClient {
186
265
  const promises: Promise<Replies.AssertExchange>[] = exchanges.map((config) => this.channel.assertExchange(config.name, config.type, config.options));
187
266
  return Promise.all(promises).then(values => {
188
267
  this.exchanges = mapify(values, 'exchange');
189
- console.log(`exchanges created on channel`);
268
+ this.log('info', 'exchanges created on channel');
190
269
  });
191
270
  })
192
271
  // apply bindings
@@ -195,30 +274,36 @@ export class RabbitMQClient {
195
274
  // bind the exclusive queue to all the exchanges
196
275
  // const exclusiveBindings = bindings.map((config) => this.channel.bindQueue(this.EXCLUSIVE_QUEUE, config.exchange, config.routingKey));
197
276
  return Promise.all(promises).then(values => {
198
- console.log(`bindings created on channel`);
277
+ this.log('info', 'bindings created on channel');
199
278
  });
200
279
  })
201
280
  .then(() => {
202
- console.log(`Client initialization complete; waiting for messages/events...\n`);
281
+ this.log('info', 'Client initialization complete; waiting for messages/events...');
203
282
 
204
283
  // initialization complete; listen for connection issues to retry again
205
284
  retryAttempts = this.clientInitConfig.retryAttempts;
206
285
 
207
286
  this.connection.on("error", (err) => {
208
287
  this.connectionErrorStream.next(err);
288
+ this.log('error', 'RabbitMQ connection error', err);
289
+ this.scheduleReconnect('RabbitMQ connection error');
209
290
  });
210
291
  this.connection.on("close", (err) => {
211
292
  this.connectionCloseStream.next(err);
293
+ this.log('warn', 'RabbitMQ connection closed', err);
294
+ this.scheduleReconnect('RabbitMQ connection closed');
212
295
  });
213
296
 
297
+ this.reconnectAttempts = 0;
214
298
  this.isReady = true;
215
299
  this.isReadyStream.next(true);
300
+ this.resubscribeToRegisteredQueues();
216
301
  })
217
302
 
218
303
  .catch((error) => {
219
- console.log(`connection error, retryAttempts: ${retryAttempts}`, error);
304
+ this.log('error', 'connection error, retryAttempts:', retryAttempts, error);
220
305
  if (retryAttempts === 0) {
221
- console.log(`all retry attemptys exhaused; exiting...`);
306
+ this.log('error', 'all retry attemptys exhaused; exiting...');
222
307
  throw error;
223
308
  }
224
309
  retryAttempts = retryAttempts - 1;
@@ -228,16 +313,16 @@ export class RabbitMQClient {
228
313
 
229
314
  return wait(delayStart || 0)
230
315
  .then(() => {
231
- console.log(`Running pre init promises...`);
316
+ this.log('info', 'Running pre init promises...');
232
317
  return Promise.all(pre_init_promises?.map(p => p instanceof Promise ? p : p()) || []).then(() => {
233
- console.log(`Done running pre init promises.\n`);
318
+ this.log('info', 'Done running pre init promises.');
234
319
  });
235
320
  })
236
321
  .then(init)
237
322
  .then(() => {
238
- console.log(`Running post init promises...`);
323
+ this.log('info', 'Running post init promises...');
239
324
  return Promise.all(post_init_promises?.map(p => p instanceof Promise ? p : p()) || []).then(() => {
240
- console.log(`Done running post init promises. \n\n-------\n\n`);
325
+ this.log('info', 'Done running post init promises.');
241
326
  });
242
327
  });
243
328
  }
@@ -265,7 +350,11 @@ export class RabbitMQClient {
265
350
  // see if a listener was created for the routing key
266
351
  const messageType = message.properties.type;
267
352
  const useContentType = message.properties.contentType;
268
- const useData = SERIALIZERS[useContentType] ? SERIALIZERS[useContentType].deserialize(message.content) : message.content;
353
+ const serializer = getSerializer(useContentType || 'application/octet-stream');
354
+ const useData = serializer ? serializer.deserialize(message.content) : message.content;
355
+ if (this.metricsEnabled) {
356
+ this.metrics.messagesReceived += 1;
357
+ }
269
358
  const messageObj: RmqEventMessage = {
270
359
  data: useData,
271
360
  message,
@@ -284,34 +373,40 @@ export class RabbitMQClient {
284
373
 
285
374
  // console.log(`Message on queue ${queue}:`, messageObj);
286
375
 
376
+ const queueListeners = this.queueToEventHandleMapping.get(queue) ?? new Map();
377
+ const queueCallbacks = this.queueToEventCallbackMapping.get(queue) ?? new Map();
378
+
287
379
  if (!messageType) {
288
380
  // no type key found, push to default stream
289
- console.log(`No message type found; pushing to default handler on queue ${queue}`);
290
- this.queueToEventHandleMapping[queue][this.DEFAULT_LISTENER_TYPE].next(messageObj);
381
+ this.log('debug', `No message type found; pushing to default handler on queue ${queue}`);
382
+ const defaultListener = queueListeners.get(this.DEFAULT_LISTENER_TYPE);
383
+ defaultListener?.next(messageObj);
291
384
  return;
292
385
  }
293
386
 
294
- if (this.queueToEventHandleMapping[queue][messageType]) {
387
+ const typeListener = queueListeners.get(messageType);
388
+ if (typeListener) {
295
389
  // there is a registered listener for the type, push to that stream
296
- console.log(`message type handler found; pushing to ${messageType} handler on queue ${queue}`);
297
- this.queueToEventHandleMapping[queue][messageType].next(messageObj);
390
+ this.log('debug', `message type handler found; pushing to ${messageType} handler on queue ${queue}`);
391
+ typeListener.next(messageObj);
298
392
  }
299
- else if (this.queueToEventCallbackMapping[queue][messageType]) {
393
+ else if (queueCallbacks.has(messageType)) {
300
394
  // there is a registered listener for the type, push to that stream
301
- console.log(`message type callback found; pushing to ${messageType} callback on queue ${queue}`);
302
- const callbackHandler = this.queueToEventCallbackMapping[queue][messageType];
395
+ this.log('debug', `message type callback found; pushing to ${messageType} callback on queue ${queue}`);
396
+ const callbackHandler = queueCallbacks.get(messageType)!;
303
397
  callbackHandler(messageObj);
304
398
  }
305
399
  else {
306
400
  // no registered listener
307
401
  if (this.clientInitConfig.autoAckUnhandledMessageTypes) {
308
- console.log(`No handler found for message type ${messageType} on queue ${queue}; auto acknowledging.`);
402
+ this.log('debug', `No handler found for message type ${messageType} on queue ${queue}; auto acknowledging.`);
309
403
  this.ack(message);
310
404
  return;
311
405
  }
312
406
  else if (this.clientInitConfig.pushUnhandledMessageTypesToDefaultHandler) {
313
- console.log(`No handler found for message type ${messageType} on queue ${queue}; pushing to ${this.DEFAULT_LISTENER_TYPE} handler.`);
314
- this.queueToEventHandleMapping[queue][this.DEFAULT_LISTENER_TYPE].next(messageObj);
407
+ this.log('debug', `No handler found for message type ${messageType} on queue ${queue}; pushing to ${this.DEFAULT_LISTENER_TYPE} handler.`);
408
+ const defaultListener = queueListeners.get(this.DEFAULT_LISTENER_TYPE);
409
+ defaultListener?.next(messageObj);
315
410
  return;
316
411
  }
317
412
  else {
@@ -327,11 +422,14 @@ export class RabbitMQClient {
327
422
 
328
423
  private listenToQueue(queue: string, options?: Options.Consume) {
329
424
  if (this.queueListeners[queue]) {
330
- console.log(`Already Registered messages/events listener for queue: ${queue}`);
425
+ this.log('debug', `Already Registered messages/events listener for queue: ${queue}`);
331
426
  return;
332
427
  }
333
428
 
334
- console.log(`Registering messages/events listener for queue: ${queue}`);
429
+ this.registeredQueueConsumers = this.registeredQueueConsumers.filter((entry) => entry.queue !== queue);
430
+ this.registeredQueueConsumers.push({ queue, options });
431
+
432
+ this.log('info', `Registering messages/events listener for queue: ${queue}`);
335
433
  const startQueueListener = this.getQueueListener(queue, options);
336
434
 
337
435
  this.messagesStreamsByQueue[queue] = new Subject<RmqEventMessage>();
@@ -342,7 +440,7 @@ export class RabbitMQClient {
342
440
  )
343
441
  .subscribe({
344
442
  next: (readyState) => {
345
- console.log(`Registered: Now listening to messages/events on queue ${queue}...`);
443
+ this.log('info', `Registered: Now listening to messages/events on queue ${queue}...`);
346
444
  }
347
445
  });
348
446
  }
@@ -354,17 +452,21 @@ export class RabbitMQClient {
354
452
  const handle = (messageType: string) => {
355
453
  return this.onReady.pipe(
356
454
  mergeMap((ready: boolean, index: number) => {
357
- if (!this.queueToEventHandleMapping[queue][messageType]) {
455
+ const queueListeners = this.queueToEventHandleMapping.get(queue);
456
+ if (!queueListeners?.has(messageType)) {
358
457
  throw new Error(`The provided routing key was not provided during initialization. Please add routing key "${messageType}" in the list of routing keys for the queue config in the constructor.`);
359
458
  }
360
- return this.queueToEventHandleMapping[queue][messageType].asObservable();
459
+ return queueListeners.get(messageType)!.asObservable();
361
460
  })
362
461
  );
363
462
  };
364
463
 
365
464
  const handleDefault = () => {
366
465
  return this.onReady.pipe(
367
- mergeMap((ready: boolean, index: number) => this.queueToEventHandleMapping[queue][this.DEFAULT_LISTENER_TYPE].asObservable())
466
+ mergeMap((ready: boolean, index: number) => {
467
+ const queueListeners = this.queueToEventHandleMapping.get(queue);
468
+ return (queueListeners?.get(this.DEFAULT_LISTENER_TYPE) ?? new ReplaySubject<RmqEventMessage>()).asObservable();
469
+ })
368
470
  );
369
471
  };
370
472
 
@@ -399,26 +501,94 @@ export class RabbitMQClient {
399
501
 
400
502
  ack(message: ConsumeMessage) {
401
503
  this.channel.ack(message);
402
- console.log(`Acknoledged rmq message.`);
504
+ if (this.metricsEnabled) {
505
+ this.metrics.messagesAcked += 1;
506
+ }
507
+ this.log('debug', 'Acknoledged rmq message.');
508
+ }
509
+
510
+ nack(message: ConsumeMessage, requeue: boolean = true) {
511
+ if (!this.channel) {
512
+ return;
513
+ }
514
+ this.channel.nack(message, false, requeue);
515
+ if (this.metricsEnabled) {
516
+ this.metrics.messagesNacked += 1;
517
+ }
518
+ this.log('debug', `Nacknowledged rmq message with requeue=${requeue}.`);
519
+ }
520
+
521
+ retryMessage(message: ConsumeMessage, options: { delayMs?: number, requeue?: boolean, queue?: string } = {}) {
522
+ const { delayMs = 0, requeue = true, queue = '' } = options;
523
+ const targetQueue = queue || message.fields.routingKey || '';
524
+ if (delayMs > 0) {
525
+ setTimeout(() => {
526
+ if (targetQueue) {
527
+ this.channel.sendToQueue(targetQueue, message.content, { persistent: true, ...message.properties });
528
+ }
529
+ }, delayMs);
530
+ }
531
+ else if (targetQueue) {
532
+ this.channel.sendToQueue(targetQueue, message.content, { persistent: true, ...message.properties });
533
+ }
534
+ this.nack(message, requeue);
535
+ if (this.metricsEnabled) {
536
+ this.metrics.messagesRetried += 1;
537
+ }
538
+ }
539
+
540
+ deadLetter(message: ConsumeMessage, reason: string, queue?: string) {
541
+ const targetQueue = queue || `${message.fields.routingKey || 'dead-letter'}.dlq`;
542
+ const headers = { ...(message.properties.headers || {}), 'x-death-reason': reason };
543
+ this.channel.sendToQueue(targetQueue, message.content, {
544
+ ...message.properties,
545
+ headers,
546
+ persistent: true,
547
+ });
548
+ this.nack(message, false);
549
+ }
550
+
551
+ async close() {
552
+ if (this.reconnectTimeout) {
553
+ clearTimeout(this.reconnectTimeout);
554
+ this.reconnectTimeout = undefined;
555
+ }
556
+
557
+ if (this.channel) {
558
+ await this.channel.close();
559
+ }
560
+ if (this.connection) {
561
+ await this.connection.close();
562
+ }
563
+
564
+ this.isReady = false;
565
+ this.isReadyStream.next(false);
566
+ this.log('info', 'RabbitMQ client closed.');
403
567
  }
404
568
 
405
569
  sendMessage(options: RmqSendMessageParams) {
406
570
  const send = () => {
407
571
  const { data, publishOptions, queue } = options;
408
572
  const useContentType = publishOptions.contentType || ContentTypes.TEXT;
409
- const useData = SERIALIZERS[useContentType] ? SERIALIZERS[useContentType].serialize(data) : data;
573
+ const serializer = getSerializer(useContentType) || SERIALIZERS[useContentType];
574
+ const useData: Buffer = serializer
575
+ ? (serializer.serialize(data) as Buffer)
576
+ : Buffer.from(typeof data === 'string' ? data : JSON.stringify(data), 'utf8');
577
+ if (this.metricsEnabled) {
578
+ this.metrics.messagesPublished += 1;
579
+ }
410
580
  this.channel.sendToQueue(queue, useData, { ...publishOptions, appId: publishOptions.appId });
411
581
  };
412
582
 
413
583
  if (!this.isReady) {
414
- console.log(`wait until ready to send message...`);
584
+ this.log('debug', 'wait until ready to send message...');
415
585
  firstValueFrom(this.onReady).then((readyState) => {
416
- console.log(`now ready to send message`, { readyState });
586
+ this.log('debug', 'now ready to send message', { readyState });
417
587
  send();
418
588
  });
419
589
  }
420
590
  else {
421
- console.log(`is ready to send message`);
591
+ this.log('debug', 'is ready to send message');
422
592
  send();
423
593
  }
424
594
  }
@@ -427,36 +597,77 @@ export class RabbitMQClient {
427
597
  queue: string,
428
598
  data: any,
429
599
  publishOptions: Options.Publish,
430
- }) {
600
+ }, autoAckOnReceiveReply: boolean, requestTimeoutMs?: number) {
431
601
  const start_time = Date.now();
432
602
  const consumerTag = uniqueValue();
433
603
  const correlationId = options.publishOptions.correlationId || uuidv4();
604
+ const timeoutMs = requestTimeoutMs ?? this.clientInitConfig.rpcRequestTimeoutMs ?? 30000;
434
605
 
435
606
  const send = () => {
436
607
  const { data, publishOptions, queue } = options;
437
608
  const useContentType = publishOptions.contentType || ContentTypes.TEXT;
438
- const useData = SERIALIZERS[useContentType] ? SERIALIZERS[useContentType].serialize(data) : data;
609
+ const serializer = getSerializer(useContentType) || SERIALIZERS[useContentType];
610
+ const useData: Buffer = serializer
611
+ ? (serializer.serialize(data) as Buffer)
612
+ : Buffer.from(typeof data === 'string' ? data : JSON.stringify(data), 'utf8');
613
+ if (this.metricsEnabled) {
614
+ this.metrics.rpcRequests += 1;
615
+ }
439
616
  this.channel.sendToQueue(queue, useData, { ...publishOptions, correlationId, replyTo: temporaryRpcQueue, appId: publishOptions.appId });
440
617
  };
441
618
 
442
619
  const watch = <T> () => {
443
620
  return new Promise<RmqEventMessage<T>>(async (resolve, reject) => {
444
- console.log(`request/rpc sent; awaiting response...`, { correlationId, consumerTag, temporaryRpcQueue });
621
+ let settled = false;
622
+ let timeoutHandle: NodeJS.Timeout | undefined;
623
+
624
+ const cleanup = async () => {
625
+ if (timeoutHandle) {
626
+ clearTimeout(timeoutHandle);
627
+ }
628
+
629
+ try {
630
+ await this.channel.cancel(consumerTag);
631
+ } catch (error) {
632
+ this.log('debug', 'Ignoring cancel failure for RPC consumer', { consumerTag, error });
633
+ }
634
+ };
635
+
636
+ timeoutHandle = setTimeout(async () => {
637
+ if (settled) {
638
+ return;
639
+ }
640
+ settled = true;
641
+ await cleanup();
642
+ reject(new Error(`RabbitMQ request timed out after ${timeoutMs}ms for correlationId ${correlationId}`));
643
+ }, timeoutMs);
644
+
645
+ this.log('debug', 'request/rpc sent; awaiting response...', { correlationId, consumerTag, temporaryRpcQueue });
445
646
 
446
647
  const replyHandler = (message: ConsumeMessage | null) => {
447
- console.log(`\nReceived reply.\n`, { message });
448
- const correlationIdMatch = message!.properties.correlationId == correlationId;
648
+ if (!message || settled) {
649
+ return;
650
+ }
651
+
652
+ this.log('debug', 'Received reply.', { message });
653
+ const correlationIdMatch = message.properties.correlationId == correlationId;
449
654
  const isReplyToRequest: boolean = !!message && correlationIdMatch;
450
- console.log({ isReplyToRequest, consumerTag, correlationIdMatch, requestCorrelationId: correlationId, responseCorrelationId: message!.properties.correlationId });
655
+ this.log('debug', { isReplyToRequest, consumerTag, correlationIdMatch, requestCorrelationId: correlationId, responseCorrelationId: message.properties.correlationId });
451
656
 
452
657
  if (isReplyToRequest) {
453
- const useContentType = message!.properties.contentType;
454
- const useData = SERIALIZERS[useContentType] ? SERIALIZERS[useContentType].deserialize(message!.content) : message!.content;
455
- const messageObj: RmqEventMessage = {
456
- data: useData,
457
- message: message!,
658
+ settled = true;
659
+ void cleanup();
660
+ const useContentType = message.properties.contentType;
661
+ const serializer = getSerializer(useContentType || 'application/octet-stream') || SERIALIZERS[useContentType || 'application/octet-stream'];
662
+ const useData = serializer ? serializer.deserialize(message.content) : message.content;
663
+ if (this.metricsEnabled) {
664
+ this.metrics.rpcResponses += 1;
665
+ }
666
+ const messageObj: RmqEventMessage<T> = {
667
+ data: useData as T,
668
+ message,
458
669
  ack: () => {
459
- this.ack(message!);
670
+ this.ack(message);
460
671
  },
461
672
  sendMessage: this.sendMessage.bind(this),
462
673
  sendRequest: this.sendRequest.bind(this),
@@ -465,18 +676,11 @@ export class RabbitMQClient {
465
676
  const end_time = Date.now();
466
677
  const total_time = (end_time - start_time) / 1000;
467
678
  const time_in_seconds = total_time.toFixed();
468
- console.log(`received response from request/rpc:`, { start_time, end_time, total_time, time_in_seconds, messageObj, options });
679
+ this.log('debug', 'received response from request/rpc:', { start_time, end_time, total_time, time_in_seconds, messageObj, options });
680
+ if (autoAckOnReceiveReply) {
681
+ this.ack(message);
682
+ }
469
683
  resolve(messageObj);
470
- // this.channel.cancel(consumerTag).then(() => {
471
- // console.log(`removed consumer via consumerTag; deleting temporary queue ${temporaryRpcQueue}...`);
472
- // this.channel.deleteQueue(temporaryRpcQueue, { ifEmpty: true, ifUnused: true })
473
- // .then(() => {
474
- // console.log(`temp queue deleted: ${temporaryRpcQueue}`);
475
- // })
476
- // .catch((error) => {
477
- // console.log(`could not delete temp queue ${temporaryRpcQueue}`);
478
- // });
479
- // });
480
684
  }
481
685
  };
482
686
 
@@ -487,41 +691,45 @@ export class RabbitMQClient {
487
691
  return { watch, send };
488
692
  }
489
693
 
490
- sendRequest <T = any> (options: {
491
- queue: string,
492
- data: any,
493
- publishOptions: Options.Publish,
494
- }) {
495
- console.log(`sendRequest:`, options);
694
+ sendRequest <T = any> (
695
+ options: {
696
+ queue: string,
697
+ data: any,
698
+ publishOptions: Options.Publish,
699
+ },
700
+ autoAckOnReceiveReply: boolean = true,
701
+ timeoutMs?: number
702
+ ) {
703
+ this.log('debug', 'sendRequest:', options);
496
704
 
497
705
  return new Promise<RmqEventMessage<T>>(async (resolve, reject) => {
498
706
 
499
707
  const temporaryRpcQueue = uuidv1();
500
708
 
501
709
  const newQueue = await this.channel.assertQueue(temporaryRpcQueue, { exclusive: true, durable: false, autoDelete: true }).then((response) => {
502
- console.log(`Created temp queue ${temporaryRpcQueue} for client.`);
710
+ this.log('debug', `Created temp queue ${temporaryRpcQueue} for client.`);
503
711
  return response;
504
712
  });
505
713
 
506
- const rpc = this.getRpcMethods(temporaryRpcQueue, options);
714
+ const rpc = this.getRpcMethods(temporaryRpcQueue, options, autoAckOnReceiveReply, timeoutMs);
507
715
 
508
716
  if (!this.isReady) {
509
- console.log(`waiting until ready to send request`);
717
+ this.log('debug', 'waiting until ready to send request');
510
718
  firstValueFrom(this.onReady).then((readyState) => {
511
- console.log(`now ready and watching temp queue`, { readyState });
719
+ this.log('debug', 'now ready and watching temp queue', { readyState });
512
720
  rpc.watch<T>().then((message: RmqEventMessage<T>) => {
513
721
  resolve(message);
514
- }); // first listen on the reply queue
515
- console.log(`sending request`);
722
+ }).catch(reject); // first listen on the reply queue
723
+ this.log('debug', 'sending request');
516
724
  rpc.send(); // then send the rpc/rmq message
517
- });
725
+ }).catch(reject);
518
726
  }
519
727
  else {
520
- console.log(`now ready and watching temp queue`);
728
+ this.log('debug', 'now ready and watching temp queue');
521
729
  rpc.watch<T>().then((message: RmqEventMessage<T>) => {
522
730
  resolve(message);
523
- }); // first listen on the reply queue
524
- console.log(`sending request`);
731
+ }).catch(reject); // first listen on the reply queue
732
+ this.log('debug', 'sending request');
525
733
  rpc.send(); // then send the rpc/rmq message
526
734
  }
527
735
  });
@@ -531,21 +739,27 @@ export class RabbitMQClient {
531
739
  const publish = () => {
532
740
  const { data, routingKey, publishOptions, exchange } = options;
533
741
  const useContentType = publishOptions.contentType || ContentTypes.TEXT;
534
- const useData = SERIALIZERS[useContentType] ? SERIALIZERS[useContentType].serialize(data) : data;
742
+ const serializer = getSerializer(useContentType) || SERIALIZERS[useContentType];
743
+ const useData: Buffer = serializer
744
+ ? (serializer.serialize(data) as Buffer)
745
+ : Buffer.from(typeof data === 'string' ? data : JSON.stringify(data), 'utf8');
746
+ if (this.metricsEnabled) {
747
+ this.metrics.messagesPublished += 1;
748
+ }
535
749
  this.channel.publish(exchange, routingKey || '', useData, { ...publishOptions, appId: publishOptions.appId });
536
750
  };
537
751
 
538
752
  if (!this.isReady) {
539
- console.log(`wait until ready to publish event`);
753
+ this.log('debug', 'wait until ready to publish event');
540
754
  this.onReady.subscribe({
541
755
  next: () => {
542
- console.log(`now ready to publish event`);
756
+ this.log('debug', 'now ready to publish event');
543
757
  publish();
544
758
  }
545
759
  });
546
760
  }
547
761
  else {
548
- console.log(`is ready to publish event`);
762
+ this.log('debug', 'is ready to publish event');
549
763
  publish();
550
764
  }
551
765
  }