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 CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: afa8e0bfe4f5c00bd91323e60c3d3e630bf1eea504495a079c667533fa98ca5a
4
- data.tar.gz: 30a30e95c8c0feaabfaf01346faddedeeea6232e97f768ed58ddde810ea6285e
3
+ metadata.gz: d6fe61ff1050738994de1718468ccdaa2b35f86dd5f80743f8b952da20300bcd
4
+ data.tar.gz: e33dd893ba8013b630a49dcd6196835e7a534c5df216d08481932a0f883d0dae
5
5
  SHA512:
6
- metadata.gz: 862f641b1555417327a7d16c7a566d43b3ed168f5cf4403ad5732e8ef7e6eba6530fbae98a530c0a73fc615b65bda4b31dc08efec34ab437bc48cc41774062d2
7
- data.tar.gz: f700b68ecae1504dc079c6702bddb4d1720c779101f0de0c9595aafc6134610fc5754c977e4b95bc48fb7348415620c860ffa074dc5dafc00841d394d265a75e
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.timeout. Es aceptable usar Timeout pese
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
- duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
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
- logger.warn "NATS: disconnected#{e ? " (#{e.message})" : ''}"
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
- logger.info "NATS: reconnected to #{@nats.connected_server}"
103
+ log_filtered(nil, "reconnected to %s", @nats.connected_server)
73
104
  end
74
105
  @nats.on_error do |e|
75
- logger.error "NATS: error: #{e.message}"
106
+ log_filtered(nil, "error: %s", e, level: :error)
76
107
  end
77
108
  @nats.on_close do
78
- logger.error "NATS: connection CLOSED permanently"
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
- log_duration(start_time, "Stream %s already exists", stream_name)
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
- log_duration(start_time, "Stream %s created", stream_name)
121
+ log_filtered(start_time, "Stream %s created", stream_name)
91
122
  rescue => e
92
- log_duration(start_time, "Failed to create stream: %s", e.message)
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
- log_duration(start_time, "Message sent to %s: %s, ACK: %s", subject, message, ack.inspect)
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
- log_duration(start_time, "Stream not found, falling back to regular NATS publish for subject %s", subject)
137
+ log_filtered(start_time, "Stream not found, falling back to regular NATS publish for subject %s", subject)
107
138
  rescue => e
108
- log_duration(start_time, "Unexpected error while publishing to %s: %s", subject, e.message)
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
- log_duration(start_time, "Message sent to %s: %s", subject, message)
145
+ log_filtered(start_time, "Message sent to %s: %s", subject, message)
115
146
  rescue => e
116
- log_duration(start_time, "Unexpected error: %s", e.message)
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
- logger.info "NATS: Subscribing to #{subject}"
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
- log_duration(start_time, "Message received on %s: %s", subject, unpacked_data.inspect)
185
+ log_filtered(start_time, "Message received on %s: %p", subject, unpacked_data)
155
186
  unpacked_data
156
187
  rescue => e
157
- log_duration(start_time, "Error while processing message on %s: %s", subject, e.message)
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
- logger.info "NATS: Sending request to #{subject} with message: #{message}"
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
- log_duration(start_time, "Received reply: %s", unpacked_response.inspect)
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
- log_duration(start_time, "Request timed out for subject: %s", subject)
205
+ log_filtered(start_time, "Request timed out for subject: %s", subject)
175
206
  nil
176
207
  rescue => e
177
- log_duration(start_time, "Unexpected error for subject %s: %s", subject, e.message)
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
- logger.info "NATS: Listening on #{subject} with reply message: #{reply_message}"
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
- logger.info "NATS: Received request on #{subject}: #{unpacked_data}"
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
- log_duration(start_time, "Replied to %s with message: %s", subject, reply.inspect)
235
+ log_filtered(start_time, "Replied to %s with message: %p", subject, reply)
205
236
  else
206
- log_duration(start_time, "No reply subject for %s, cannot respond", subject)
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
- log_duration(start_time, "Error while processing message on %s: %s", subject, e.message)
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
- log_duration(start_time, "Error while replying: %s", e.message)
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
@@ -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.6.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-07-10 00:00:00.000000000 Z
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.5.16
110
+ rubygems_version: 3.0.9
111
111
  signing_key:
112
112
  specification_version: 4
113
113
  summary: a NATS service for messaging