15826451024

Committed 23 Jun 2025 02:03PM UTC coverage: 92.1% (-0.3%) from 92.398%

Build # 15826451024

Build Type

push

github

Committed by

web-flow

Commit Message

Logger args are now deferred like in tainbox gem (#34)

Run Details

54 of 72 branches covered (75.0%)

Branch coverage included in aggregate %.

8 of 9 new or added lines in 1 file covered. (88.89%)

1 existing line in 1 file now uncovered.

424 of 447 relevant lines covered (94.85%)

7.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.58

/lib/rabbit.rb

# frozen_string_literal: true

require "rabbit/version"
require "rabbit/daemon"
require "rabbit/publishing"
require "rabbit/event_handler"

require "rabbit/extensions/bunny/channel"

module Rabbit
  InvalidConfig = Class.new(StandardError)
  MessageNotDelivered = Class.new(StandardError)

  class Config
    attr_accessor :group_id,
                  :project_id,
                  :queue_suffix,
                  :hooks,
                  :environment,
                  :queue_name_conversion,
                  :receiving_job_class_callable,
                  :handler_resolver_callable,
                  :exception_notifier,
                  :before_receiving_hooks,
                  :after_receiving_hooks,
                  :skip_publishing_in,
                  :use_backoff_handler,
                  :backoff_handler_max_retries,
                  :connection_reset_max_retries,
                  :connection_reset_timeout,
                  :connection_reset_exceptions,
                  :logger_message_size_limit

    def initialize( # rubocop:disable Metrics/MethodLength
      group_id: nil,
      project_id: nil,
      queue_suffix: nil,
      hooks: {},
      environment: :production,
      queue_name_conversion: nil,
      receiving_job_class_callable: nil,
      handler_resolver_callable: nil,
      exception_notifier: nil,
      before_receiving_hooks: [],
      after_receiving_hooks: [],
      skip_publishing_in: %i[test development],
      use_backoff_handler: false,
      backoff_handler_max_retries: 6,
      connection_reset_max_retries: 10,
      connection_reset_timeout: 0.2,
      connection_reset_exceptions: [Bunny::ConnectionClosedError],
      logger_message_size_limit: 9_500,
      receive_logger: nil,
      publish_logger: nil,
      malformed_logger: nil
    )
      self.group_id = group_id
      self.project_id = project_id
      self.queue_suffix = queue_suffix
      self.hooks = hooks
      self.environment = environment
      self.queue_name_conversion = queue_name_conversion
      self.receiving_job_class_callable = receiving_job_class_callable
      self.handler_resolver_callable = handler_resolver_callable
      self.exception_notifier = exception_notifier
      self.before_receiving_hooks = before_receiving_hooks
      self.after_receiving_hooks = after_receiving_hooks
      self.skip_publishing_in = skip_publishing_in
      self.use_backoff_handler = use_backoff_handler
      self.backoff_handler_max_retries = backoff_handler_max_retries
      self.connection_reset_max_retries = connection_reset_max_retries
      self.connection_reset_timeout = connection_reset_timeout
      self.connection_reset_exceptions = connection_reset_exceptions
      self.logger_message_size_limit = logger_message_size_limit

      @receive_logger = receive_logger
      @publish_logger = publish_logger
      @malformed_logger = malformed_logger
    end

    def validate!
      raise InvalidConfig, "missing project_id" unless project_id
      raise InvalidConfig, "missing group_id" unless group_id
      raise InvalidConfig, "missing exception_notifier" unless exception_notifier

      unless %i[test development production].include?(environment)
        raise "environment should be one of (test, development, production)"
      end
    end

    def skip_publish?
      skip_publishing_in.include?(environment)
    end

    def app_name
      [group_id, project_id].join(".")
    end

    def read_queue
      [app_name, queue_suffix].reject { |x| x.nil? || x.empty? }.join(".")
    end

    def receive_logger
      @receive_logger || default_receive_logger
    end

    def publish_logger
      @publish_logger || default_publish_logger
    end

    def malformed_logger
      @malformed_logger || default_malformed_logger
    end

    private

    def default_receive_logger
      Logger.new(Rabbit.root.join("log", "incoming_rabbit_messages.log"))
    end

    def default_publish_logger
      Logger.new(Rabbit.root.join("log", "rabbit.log"))
    end

    def default_malformed_logger
      Logger.new(Rabbit.root.join("log", "malformed_messages.log"))
    end
  end

  extend self

  def config
    @config ||= Config.new
    yield(@config) if block_given?
    @config
  end

  def root
    if defined?(Rails)
      Rails.root
    else
      Pathname.new(Dir.pwd)
    end
  end

  def sneakers_config
    if defined?(Rails)
      Rails.application.config_for("sneakers")
    else
      config = YAML.load_file("config/sneakers.yml", aliases: true)
      config[Rabbit.config.environment.to_s].to_h.symbolize_keys
    end
  end

  def configure
    yield(config)
    config.validate!
  end

  def publish(message_options)
    message = Publishing::Message.new(message_options)

    if message.realtime?
      Publishing.publish(message)
    else
      Publishing::Job.set(queue: default_queue_name).perform_later(message.to_hash)
    end
  end

  def queue_name(queue, ignore_conversion: false)
    return queue if ignore_conversion
    config.queue_name_conversion ? config.queue_name_conversion.call(queue) : queue
  end

  def default_queue_name(ignore_conversion: false)
    queue_name(:default, ignore_conversion: ignore_conversion)
  end
end

1	# frozen_string_literal: true
2
3	require "rabbit/version"	1✔
4	require "rabbit/daemon"	1✔
5	require "rabbit/publishing"	1✔
6	require "rabbit/event_handler"	1✔
7
8	require "rabbit/extensions/bunny/channel"	1✔
9
10	module Rabbit	1✔
11	InvalidConfig = Class.new(StandardError)	1✔
12	MessageNotDelivered = Class.new(StandardError)	1✔
13
14	class Config	1✔
15	attr_accessor :group_id,	1✔
16	:project_id,
17	:queue_suffix,
18	:hooks,
19	:environment,
20	:queue_name_conversion,
21	:receiving_job_class_callable,
22	:handler_resolver_callable,
23	:exception_notifier,
24	:before_receiving_hooks,
25	:after_receiving_hooks,
26	:skip_publishing_in,
27	:use_backoff_handler,
28	:backoff_handler_max_retries,
29	:connection_reset_max_retries,
30	:connection_reset_timeout,
31	:connection_reset_exceptions,
32	:logger_message_size_limit
33
34	def initialize( # rubocop:disable Metrics/MethodLength	1✔
35	group_id: nil,
36	project_id: nil,
37	queue_suffix: nil,
38	hooks: {},
39	environment: :production,
40	queue_name_conversion: nil,
41	receiving_job_class_callable: nil,
42	handler_resolver_callable: nil,
43	exception_notifier: nil,
44	before_receiving_hooks: [],
45	after_receiving_hooks: [],
46	skip_publishing_in: %i[test development],
47	use_backoff_handler: false,
48	backoff_handler_max_retries: 6,
49	connection_reset_max_retries: 10,
50	connection_reset_timeout: 0.2,
51	connection_reset_exceptions: [Bunny::ConnectionClosedError],
52	logger_message_size_limit: 9_500,
53	receive_logger: nil,
54	publish_logger: nil,
55	malformed_logger: nil
56	)
57	self.group_id = group_id	1✔
58	self.project_id = project_id	1✔
59	self.queue_suffix = queue_suffix	1✔
60	self.hooks = hooks	1✔
61	self.environment = environment	1✔
62	self.queue_name_conversion = queue_name_conversion	1✔
63	self.receiving_job_class_callable = receiving_job_class_callable	1✔
64	self.handler_resolver_callable = handler_resolver_callable	1✔
65	self.exception_notifier = exception_notifier	1✔
66	self.before_receiving_hooks = before_receiving_hooks	1✔
67	self.after_receiving_hooks = after_receiving_hooks	1✔
68	self.skip_publishing_in = skip_publishing_in	1✔
69	self.use_backoff_handler = use_backoff_handler	1✔
70	self.backoff_handler_max_retries = backoff_handler_max_retries	1✔
71	self.connection_reset_max_retries = connection_reset_max_retries	1✔
72	self.connection_reset_timeout = connection_reset_timeout	1✔
73	self.connection_reset_exceptions = connection_reset_exceptions	1✔
74	self.logger_message_size_limit = logger_message_size_limit	1✔
75
76	@receive_logger = receive_logger	1✔
77	@publish_logger = publish_logger	1✔
78	@malformed_logger = malformed_logger	1✔
79	end
80
81	def validate!	1✔
82	raise InvalidConfig, "missing project_id" unless project_id	14!
83	raise InvalidConfig, "missing group_id" unless group_id	14!
84	raise InvalidConfig, "missing exception_notifier" unless exception_notifier	14!
85
86	unless %i[test development production].include?(environment)	14!
87	raise "environment should be one of (test, development, production)"	×
88	end
89	end
90
91	def skip_publish?	1✔
92	skip_publishing_in.include?(environment)	4✔
93	end
94
95	def app_name	1✔
96	[group_id, project_id].join(".")	20✔
97	end
98
99	def read_queue	1✔
100	[app_name, queue_suffix].reject { \|x\| x.nil? \|\| x.empty? }.join(".")	24✔
101	end
102
103	def receive_logger	1✔
104	@receive_logger \|\| default_receive_logger	16✔
105	end
106
107	def publish_logger	1✔
NEW 108	@publish_logger \|\| default_publish_logger	×
109	end
110
111	def malformed_logger	1✔
112	@malformed_logger \|\| default_malformed_logger	1✔
113	end
114
115	private	1✔
116
117	def default_receive_logger	1✔
118	Logger.new(Rabbit.root.join("log", "incoming_rabbit_messages.log"))	16✔
119	end
120
121	def default_publish_logger	1✔
UNCOV 122	Logger.new(Rabbit.root.join("log", "rabbit.log"))	×
123	end
124
125	def default_malformed_logger	1✔
126	Logger.new(Rabbit.root.join("log", "malformed_messages.log"))	1✔
127	end
128	end
129
130	extend self	1✔
131
132	def config	1✔
133	@config \|\|= Config.new	349✔
134	yield(@config) if block_given?	349!
135	@config	349✔
136	end
137
138	def root	1✔
139	if defined?(Rails)	17!
140	Rails.root	×
141	else	17✔
142	Pathname.new(Dir.pwd)	17✔
143	end
144	end
145
146	def sneakers_config	1✔
147	if defined?(Rails)	9!
148	Rails.application.config_for("sneakers")	×
149	else	9✔
150	config = YAML.load_file("config/sneakers.yml", aliases: true)	9✔
151	config[Rabbit.config.environment.to_s].to_h.symbolize_keys	9✔
152	end
153	end
154
155	def configure	1✔
156	yield(config)	×
157	config.validate!	×
158	end
159
160	def publish(message_options)	1✔
161	message = Publishing::Message.new(message_options)	4✔
162
163	if message.realtime?	4✔
164	Publishing.publish(message)	3✔
165	else	1✔
166	Publishing::Job.set(queue: default_queue_name).perform_later(message.to_hash)	1✔
167	end
168	end
169
170	def queue_name(queue, ignore_conversion: false)	1✔
171	return queue if ignore_conversion	14✔
172	config.queue_name_conversion ? config.queue_name_conversion.call(queue) : queue	12!
173	end
174
175	def default_queue_name(ignore_conversion: false)	1✔
176	queue_name(:default, ignore_conversion: ignore_conversion)	3✔
177	end
178	end

umbrellio / rabbit_messaging / 15826451024

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous