nats_messaging 1.6.1 → 1.7.0
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.
- checksums.yaml +4 -4
- data/lib/nats_messaging/nats_service.rb +166 -34
- data/lib/nats_messaging.rb +4 -2
- metadata +3 -3
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: d6fe61ff1050738994de1718468ccdaa2b35f86dd5f80743f8b952da20300bcd
|
|
4
|
+
data.tar.gz: e33dd893ba8013b630a49dcd6196835e7a534c5df216d08481932a0f883d0dae
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: '0390c4cf09fe9f3423cd12b1c92a5e8447953558dd5bca37ddb8cc47ed14a6fa6df1234a39258fc0e9c5e53daa770b6ef19d714a853727a554eb74b037d8530a'
|
|
7
|
+
data.tar.gz: 291a5c3d3bffd7348ac55f3031dbe4e2e6ac033ff7c3170fcdcd0545ae6ced815b745f2f2fdc120af40ed0e14445f5700efefd19b35b0b6deb41725a08aecc3c
|
|
@@ -2,8 +2,10 @@ require 'nats/io/client'
|
|
|
2
2
|
require 'msgpack'
|
|
3
3
|
require 'logger'
|
|
4
4
|
require 'active_support'
|
|
5
|
+
require 'active_support/parameter_filter'
|
|
5
6
|
require 'active_support/core_ext/hash/indifferent_access'
|
|
6
7
|
require 'timeout'
|
|
8
|
+
require 'json'
|
|
7
9
|
|
|
8
10
|
module NatsMessaging
|
|
9
11
|
class NatsService
|
|
@@ -27,18 +29,22 @@ module NatsMessaging
|
|
|
27
29
|
# limita un intento de conexión TCP/handshake individual, no la cantidad
|
|
28
30
|
# de reintentos. No hay forma nativa en nats-pure 2.5 de distinguir
|
|
29
31
|
# "primer connect" de "reconexión posterior", así que se acota el connect
|
|
30
|
-
# inicial desde afuera con Timeout.
|
|
31
|
-
# a su conocida rudeza (mata el hilo sin dar chance de cleanup) porque
|
|
32
|
-
# ocurre solo durante el boot, antes de que exista estado que corromper;
|
|
33
|
-
# si el timeout dispara, la instancia parcialmente construida simplemente
|
|
34
|
-
# se descarta al propagar la excepción.
|
|
32
|
+
# inicial desde afuera con Timeout.
|
|
35
33
|
DEFAULT_INITIAL_CONNECT_TIMEOUT = 15
|
|
36
34
|
|
|
35
|
+
# Los payloads pueden traer documentos en base64 (varios MB) además de
|
|
36
|
+
# tokens/passwords. Además de los filter_parameters, cualquier String que
|
|
37
|
+
# supere este tamaño en bytes se reemplaza en el log por
|
|
38
|
+
# "[FILTERED N bytes]". Se puede desactivar con log_max_value_bytes: nil.
|
|
39
|
+
DEFAULT_LOG_MAX_VALUE_BYTES = 1024
|
|
40
|
+
|
|
37
41
|
attr_reader :pid
|
|
38
42
|
|
|
39
|
-
def initialize(nats_url, stream_name: nil, subjects: [], connect_options: {}, initial_connect_timeout: DEFAULT_INITIAL_CONNECT_TIMEOUT)
|
|
43
|
+
def initialize(nats_url, stream_name: nil, subjects: [], connect_options: {}, initial_connect_timeout: DEFAULT_INITIAL_CONNECT_TIMEOUT, filter_parameters: nil, log_max_value_bytes: DEFAULT_LOG_MAX_VALUE_BYTES)
|
|
40
44
|
@pid = Process.pid
|
|
41
45
|
@subscriptions = {} # Store active subscriptions
|
|
46
|
+
@filter_parameters = filter_parameters
|
|
47
|
+
@log_max_value_bytes = log_max_value_bytes
|
|
42
48
|
begin
|
|
43
49
|
@nats = Timeout.timeout(initial_connect_timeout) do
|
|
44
50
|
NATS.connect(nats_url, DEFAULT_CONNECT_OPTIONS.merge(connect_options))
|
|
@@ -58,24 +64,49 @@ module NatsMessaging
|
|
|
58
64
|
@logger ||= (defined?(Rails) && Rails.logger) || Logger.new(STDOUT)
|
|
59
65
|
end
|
|
60
66
|
|
|
67
|
+
# Punto de entrada ÚNICO de logging del gem. Todos los +args+ pasan por
|
|
68
|
+
# sanitize_for_log antes de formatearse, de modo que ninguna línea puede
|
|
69
|
+
# escribir un payload o el mensaje de una excepción sin filtrar. No
|
|
70
|
+
# interpolar nada directamente en logger.* dentro del gem.
|
|
71
|
+
#
|
|
72
|
+
# Con +start_time+ (Process.clock_gettime monotónico) el prefijo es
|
|
73
|
+
# "NATS [%.2fs]: "; con nil es "NATS: ". Los args se sustituyen en
|
|
74
|
+
# +message_format+ con String#%: usar %s para texto sin comillas y %p para
|
|
75
|
+
# el inspect (Strings entre comillas, nil como "nil"). +level+ es el nivel
|
|
76
|
+
# del logger; si está deshabilitado se retorna sin sanitizar ni formatear.
|
|
77
|
+
def log_filtered(start_time, message_format, *args, level: :info)
|
|
78
|
+
predicate = :"#{level}?"
|
|
79
|
+
return if logger.respond_to?(predicate) && !logger.public_send(predicate)
|
|
80
|
+
|
|
81
|
+
prefix = if start_time
|
|
82
|
+
format("NATS [%.2fs]: ", Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time)
|
|
83
|
+
else
|
|
84
|
+
"NATS: "
|
|
85
|
+
end
|
|
86
|
+
logger.public_send(level, prefix + (message_format % args.map { |arg| sanitize_for_log(arg) }))
|
|
87
|
+
end
|
|
88
|
+
|
|
89
|
+
# Deprecado: usar log_filtered. Se mantiene por compatibilidad y también filtra.
|
|
61
90
|
def log_duration(start_time, message_format, *args)
|
|
62
|
-
|
|
63
|
-
full_message = "NATS [%.2fs]: #{message_format}" % [duration, *args]
|
|
64
|
-
logger.info full_message
|
|
91
|
+
log_filtered(start_time, message_format, *args)
|
|
65
92
|
end
|
|
66
93
|
|
|
67
94
|
def register_lifecycle_callbacks
|
|
68
95
|
@nats.on_disconnect do |e|
|
|
69
|
-
|
|
96
|
+
if e
|
|
97
|
+
log_filtered(nil, "disconnected (%s)", e, level: :warn)
|
|
98
|
+
else
|
|
99
|
+
log_filtered(nil, "disconnected", level: :warn)
|
|
100
|
+
end
|
|
70
101
|
end
|
|
71
102
|
@nats.on_reconnect do
|
|
72
|
-
|
|
103
|
+
log_filtered(nil, "reconnected to %s", @nats.connected_server)
|
|
73
104
|
end
|
|
74
105
|
@nats.on_error do |e|
|
|
75
|
-
|
|
106
|
+
log_filtered(nil, "error: %s", e, level: :error)
|
|
76
107
|
end
|
|
77
108
|
@nats.on_close do
|
|
78
|
-
|
|
109
|
+
log_filtered(nil, "connection CLOSED permanently", level: :error)
|
|
79
110
|
end
|
|
80
111
|
end
|
|
81
112
|
|
|
@@ -84,12 +115,12 @@ module NatsMessaging
|
|
|
84
115
|
begin
|
|
85
116
|
start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
|
|
86
117
|
stream = @js.stream_info(stream_name)
|
|
87
|
-
|
|
118
|
+
log_filtered(start_time, "Stream %s already exists", stream_name)
|
|
88
119
|
rescue NATS::JetStream::Error::NotFound
|
|
89
120
|
@js.add_stream(name: stream_name, subjects: subjects)
|
|
90
|
-
|
|
121
|
+
log_filtered(start_time, "Stream %s created", stream_name)
|
|
91
122
|
rescue => e
|
|
92
|
-
|
|
123
|
+
log_filtered(start_time, "Failed to create stream: %s", e, level: :error)
|
|
93
124
|
end
|
|
94
125
|
end
|
|
95
126
|
|
|
@@ -100,20 +131,20 @@ module NatsMessaging
|
|
|
100
131
|
begin
|
|
101
132
|
start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
|
|
102
133
|
ack = @js.publish(subject, packed_message)
|
|
103
|
-
|
|
134
|
+
log_filtered(start_time, "Message sent to %s: %s, ACK: %s", subject, message, ack.inspect)
|
|
104
135
|
rescue NATS::JetStream::Error::NotFound
|
|
105
136
|
@nats.publish(subject, packed_message)
|
|
106
|
-
|
|
137
|
+
log_filtered(start_time, "Stream not found, falling back to regular NATS publish for subject %s", subject)
|
|
107
138
|
rescue => e
|
|
108
|
-
|
|
139
|
+
log_filtered(start_time, "Unexpected error while publishing to %s: %s", subject, e, level: :error)
|
|
109
140
|
end
|
|
110
141
|
else
|
|
111
142
|
begin
|
|
112
143
|
start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
|
|
113
144
|
@nats.publish(subject, packed_message)
|
|
114
|
-
|
|
145
|
+
log_filtered(start_time, "Message sent to %s: %s", subject, message)
|
|
115
146
|
rescue => e
|
|
116
|
-
|
|
147
|
+
log_filtered(start_time, "Unexpected error: %s", e, level: :error)
|
|
117
148
|
end
|
|
118
149
|
end
|
|
119
150
|
end
|
|
@@ -128,7 +159,7 @@ module NatsMessaging
|
|
|
128
159
|
|
|
129
160
|
# Subscribe to a subject using MessagePack
|
|
130
161
|
def subscribe_to_subject(subject, durable_name = "durable_name")
|
|
131
|
-
|
|
162
|
+
log_filtered(nil, "Subscribing to %s", subject)
|
|
132
163
|
if @js
|
|
133
164
|
@subscriptions[subject] = @js.subscribe(subject, durable: durable_name) do |msg|
|
|
134
165
|
unpacked_data = process_received_message(msg, subject)
|
|
@@ -151,30 +182,30 @@ module NatsMessaging
|
|
|
151
182
|
begin
|
|
152
183
|
start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
|
|
153
184
|
unpacked_data = MessagePack.unpack(msg.data)
|
|
154
|
-
|
|
185
|
+
log_filtered(start_time, "Message received on %s: %p", subject, unpacked_data)
|
|
155
186
|
unpacked_data
|
|
156
187
|
rescue => e
|
|
157
|
-
|
|
188
|
+
log_filtered(start_time, "Error while processing message on %s: %s", subject, e, level: :error)
|
|
158
189
|
end
|
|
159
190
|
end
|
|
160
191
|
|
|
161
192
|
# Send a request to a subject and wait for response using MessagePack
|
|
162
193
|
def send_request(subject, message, timeout = 5)
|
|
163
|
-
|
|
194
|
+
log_filtered(nil, "Sending request to %s with message: %s", subject, message)
|
|
164
195
|
start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
|
|
165
196
|
begin
|
|
166
197
|
packed_message = message.to_msgpack # Serializar el mensaje
|
|
167
198
|
response = @nats.request(subject, packed_message, timeout: timeout) # Timeout of 5 seconds or custom
|
|
168
199
|
unpacked_response = MessagePack.unpack(response.data) # Deserializar respuesta
|
|
169
|
-
|
|
200
|
+
log_filtered(start_time, "Received reply: %p", unpacked_response)
|
|
170
201
|
indifferent_unpacked_data = make_data_indifferent(unpacked_response)
|
|
171
202
|
yield(subject, indifferent_unpacked_data) if block_given?
|
|
172
203
|
indifferent_unpacked_data
|
|
173
204
|
rescue NATS::IO::Timeout
|
|
174
|
-
|
|
205
|
+
log_filtered(start_time, "Request timed out for subject: %s", subject)
|
|
175
206
|
nil
|
|
176
207
|
rescue => e
|
|
177
|
-
|
|
208
|
+
log_filtered(start_time, "Unexpected error for subject %s: %s", subject, e, level: :error)
|
|
178
209
|
nil
|
|
179
210
|
end
|
|
180
211
|
end
|
|
@@ -187,13 +218,13 @@ module NatsMessaging
|
|
|
187
218
|
end
|
|
188
219
|
begin
|
|
189
220
|
# Create a new subscription
|
|
190
|
-
|
|
221
|
+
log_filtered(nil, "Listening on %s with reply message: %s", subject, reply_message)
|
|
191
222
|
start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) # En caso de que falle antes del segundo begin
|
|
192
223
|
@subscriptions[subject] = @nats.subscribe(subject) do |msg|
|
|
193
224
|
begin
|
|
194
225
|
start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
|
|
195
226
|
unpacked_data = MessagePack.unpack(msg.data) # Deserializar mensaje recibido
|
|
196
|
-
|
|
227
|
+
log_filtered(nil, "Received request on %s: %s", subject, unpacked_data)
|
|
197
228
|
indifferent_unpacked_data = make_data_indifferent(unpacked_data)
|
|
198
229
|
yield_return = yield(subject, indifferent_unpacked_data) if block_given?
|
|
199
230
|
reply = reply_message.nil? ? yield_return : reply_message
|
|
@@ -201,19 +232,120 @@ module NatsMessaging
|
|
|
201
232
|
# Asegurar que msg.reply existe antes de responder
|
|
202
233
|
if msg.reply
|
|
203
234
|
@nats.publish(msg.reply, packed_reply)
|
|
204
|
-
|
|
235
|
+
log_filtered(start_time, "Replied to %s with message: %p", subject, reply)
|
|
205
236
|
else
|
|
206
|
-
|
|
237
|
+
log_filtered(start_time, "No reply subject for %s, cannot respond", subject)
|
|
207
238
|
end
|
|
208
239
|
indifferent_unpacked_data
|
|
209
240
|
rescue => e
|
|
210
|
-
|
|
241
|
+
log_filtered(start_time, "Error while processing message on %s: %s", subject, e, level: :error)
|
|
211
242
|
logger.error e.backtrace.join("\n")
|
|
212
243
|
end
|
|
213
244
|
end
|
|
214
245
|
rescue => e
|
|
215
|
-
|
|
246
|
+
log_filtered(start_time, "Error while replying: %s", e, level: :error)
|
|
247
|
+
end
|
|
248
|
+
end
|
|
249
|
+
|
|
250
|
+
private
|
|
251
|
+
|
|
252
|
+
# Devuelve un objeto seguro para formatear: Hash/Array filtrados (sin
|
|
253
|
+
# convertirlos antes a texto), Strings con límite y filtrado de JSON,
|
|
254
|
+
# excepciones como texto sin payload, y el resto limitado en tamaño.
|
|
255
|
+
def sanitize_for_log(obj)
|
|
256
|
+
case obj
|
|
257
|
+
when Hash, Array then filter_for_log(obj)
|
|
258
|
+
when String then sanitize_string(obj)
|
|
259
|
+
when Exception then sanitize_exception(obj)
|
|
260
|
+
when nil, true, false, Numeric, Symbol then obj
|
|
261
|
+
else guard_for_log(obj.inspect)
|
|
262
|
+
end
|
|
263
|
+
rescue StandardError
|
|
264
|
+
# Un fallo al filtrar nunca debe romper el flujo de mensajería.
|
|
265
|
+
"[unloggable #{obj.class}]"
|
|
266
|
+
end
|
|
267
|
+
|
|
268
|
+
# Superado el límite se reemplaza sin parsear nada. Si no, y parece JSON
|
|
269
|
+
# (empieza con { o [), se parsea y se loguea filtrado como JSON; si no
|
|
270
|
+
# parsea o no es Hash/Array se loguea tal cual.
|
|
271
|
+
def sanitize_string(string)
|
|
272
|
+
guarded = guard_for_log(string)
|
|
273
|
+
return guarded unless guarded.equal?(string)
|
|
274
|
+
|
|
275
|
+
parsed = begin
|
|
276
|
+
JSON.parse(string) if string.lstrip.start_with?("{", "[")
|
|
277
|
+
rescue StandardError
|
|
278
|
+
nil
|
|
216
279
|
end
|
|
280
|
+
parsed.is_a?(Hash) || parsed.is_a?(Array) ? filter_for_log(parsed).to_json : string
|
|
281
|
+
end
|
|
282
|
+
|
|
283
|
+
# Clase + mensaje seguro. En NameError/NoMethodError (Ruby < 3.4) y
|
|
284
|
+
# FrozenError el mensaje incluye el inspect del receptor, que puede ser el
|
|
285
|
+
# payload completo: se reconstruye sin receptor. Lo mismo con
|
|
286
|
+
# NoMatchingPatternError (su mensaje es el inspect del valor) y
|
|
287
|
+
# NoMatchingPatternKeyError (valor + clave): de esta última solo se deja la
|
|
288
|
+
# clave. El resto del mensaje pasa por sanitize_string.
|
|
289
|
+
def sanitize_exception(error)
|
|
290
|
+
detail = case error
|
|
291
|
+
when ->(e) { key_error?(e) } then "key not found: #{error.key.inspect}"
|
|
292
|
+
when NoMatchingPatternError then "no pattern matched"
|
|
293
|
+
when NoMethodError then "undefined method '#{error.name}'"
|
|
294
|
+
when NameError then "undefined local variable or constant '#{error.name}'"
|
|
295
|
+
when FrozenError then "can't modify frozen object"
|
|
296
|
+
else sanitize_string(error.message.to_s)
|
|
297
|
+
end
|
|
298
|
+
"#{error.class}: #{detail}"
|
|
299
|
+
end
|
|
300
|
+
|
|
301
|
+
# NoMatchingPatternKeyError existe desde Ruby 3.1 (el gemspec exige >= 3.0).
|
|
302
|
+
def key_error?(error)
|
|
303
|
+
defined?(NoMatchingPatternKeyError) && error.is_a?(NoMatchingPatternKeyError)
|
|
304
|
+
end
|
|
305
|
+
|
|
306
|
+
def filter_for_log(obj)
|
|
307
|
+
case obj
|
|
308
|
+
when Hash then parameter_filter.filter(obj)
|
|
309
|
+
when Array then obj.map { |item| filter_for_log(item) }
|
|
310
|
+
when String then guard_for_log(obj)
|
|
311
|
+
else obj
|
|
312
|
+
end
|
|
313
|
+
end
|
|
314
|
+
|
|
315
|
+
# bytesize (y no regex ni length) para soportar encodings inválidos o binarios.
|
|
316
|
+
# Única definición del marcador: la reutiliza el filtro de valores anidados.
|
|
317
|
+
def guard_for_log(string)
|
|
318
|
+
return string if @log_max_value_bytes.nil? || string.bytesize <= @log_max_value_bytes
|
|
319
|
+
|
|
320
|
+
"[FILTERED #{string.bytesize} bytes]"
|
|
321
|
+
end
|
|
322
|
+
|
|
323
|
+
# Resolución perezosa: los initializers de la app agregan filtros a
|
|
324
|
+
# Rails.application.config.filter_parameters después de que el gem se
|
|
325
|
+
# inicializa (y `+=` crea un Array nuevo), así que se lee en cada log y el
|
|
326
|
+
# ParameterFilter se reconstruye si la lista de origen cambió (otro objeto
|
|
327
|
+
# o distinto tamaño).
|
|
328
|
+
def parameter_filter
|
|
329
|
+
source = @filter_parameters || rails_filter_parameters
|
|
330
|
+
size = source.respond_to?(:size) ? source.size : nil
|
|
331
|
+
return @parameter_filter if @parameter_filter && @parameter_filter_source.equal?(source) && @parameter_filter_size == size
|
|
332
|
+
|
|
333
|
+
# ParameterFilter duplica el valor antes de llamar los bloques, por lo
|
|
334
|
+
# que replace no toca el original.
|
|
335
|
+
size_guard = lambda { |_key, value|
|
|
336
|
+
guarded = guard_for_log(value) if value.is_a?(String)
|
|
337
|
+
value.replace(guarded) if guarded && !guarded.equal?(value)
|
|
338
|
+
}
|
|
339
|
+
filter = ActiveSupport::ParameterFilter.new(Array(source) + [size_guard])
|
|
340
|
+
@parameter_filter_source = source
|
|
341
|
+
@parameter_filter_size = size
|
|
342
|
+
@parameter_filter = filter
|
|
343
|
+
end
|
|
344
|
+
|
|
345
|
+
def rails_filter_parameters
|
|
346
|
+
return [] unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
|
|
347
|
+
|
|
348
|
+
Rails.application.config.filter_parameters
|
|
217
349
|
end
|
|
218
350
|
end
|
|
219
351
|
end
|
data/lib/nats_messaging.rb
CHANGED
|
@@ -14,14 +14,16 @@ module NatsMessaging
|
|
|
14
14
|
# socket pertenece al padre) y se descarta sin intentar cerrarla, creando una
|
|
15
15
|
# instancia nueva con los parámetros de ESTA llamada. Dentro del mismo PID la
|
|
16
16
|
# memoización ignora los parámetros de llamadas posteriores, igual que antes.
|
|
17
|
-
def self.service(nats_url, stream_name: nil, subjects: [], connect_options: {}, initial_connect_timeout: NatsService::DEFAULT_INITIAL_CONNECT_TIMEOUT)
|
|
17
|
+
def self.service(nats_url, stream_name: nil, subjects: [], connect_options: {}, initial_connect_timeout: NatsService::DEFAULT_INITIAL_CONNECT_TIMEOUT, filter_parameters: nil, log_max_value_bytes: NatsService::DEFAULT_LOG_MAX_VALUE_BYTES)
|
|
18
18
|
@service = nil if @service && @service.pid != Process.pid
|
|
19
19
|
@service ||= NatsService.new(
|
|
20
20
|
nats_url,
|
|
21
21
|
stream_name: stream_name,
|
|
22
22
|
subjects: subjects,
|
|
23
23
|
connect_options: connect_options,
|
|
24
|
-
initial_connect_timeout: initial_connect_timeout
|
|
24
|
+
initial_connect_timeout: initial_connect_timeout,
|
|
25
|
+
filter_parameters: filter_parameters,
|
|
26
|
+
log_max_value_bytes: log_max_value_bytes
|
|
25
27
|
)
|
|
26
28
|
end
|
|
27
29
|
end
|
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: nats_messaging
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 1.
|
|
4
|
+
version: 1.7.0
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Bea Graboloza
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: bin
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date: 2026-
|
|
11
|
+
date: 2026-11-03 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: nats-pure
|
|
@@ -107,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
|
107
107
|
- !ruby/object:Gem::Version
|
|
108
108
|
version: '0'
|
|
109
109
|
requirements: []
|
|
110
|
-
rubygems_version: 3.
|
|
110
|
+
rubygems_version: 3.0.9
|
|
111
111
|
signing_key:
|
|
112
112
|
specification_version: 4
|
|
113
113
|
summary: a NATS service for messaging
|