rails_semantic_logger 4.16.0 → 4.17.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: 7da18e2122c13f2b4325a6f3000dd74d22517608b3a32355ca3d2bf4e5f08789
4
- data.tar.gz: b0503c3227cb0bfa5faa1c6f00b408968783c8d09092a960497ab9f004798875
3
+ metadata.gz: 9a96d9dc4eb844eb8561d52f66dc27e2e07edb6b61da2163b0351ce3b12759ff
4
+ data.tar.gz: 34145d723bd89d14e5377200862df57829739b2ee5e5422a58f1d0edd4cbff0f
5
5
  SHA512:
6
- metadata.gz: 30446e6a7553868e37cb56550d0a3e5c15b137991609e2cbb7aee84c7c7f5a75abe0bdd7f5e6263418546645f7a0892472e042ee09e0764be9f0ff9d90311917
7
- data.tar.gz: 051ff94e24b1d9a4231f01d4148a966333b8d7b57539f7fa15ab953ad0a2fc9c998b61413ae2350716763f323eafa6d7302893b0c7b691e165c2200f7a8f3ef1
6
+ metadata.gz: e99c63ad9e4d02377d5ea25ba528f5de4fa8f83a2aadd7ef19ef2e3b8f52fc67cd2d08130ec18478ab4e5a2785657928f4e863024d8214a76de3bff4618b6891
7
+ data.tar.gz: 2d6ccc0cb9e385a2ca3a0fdc65023948f968a83b044768fc9bc9ccfb78452d7d4325731cdc4c5397bb097efa1ad72a1ce05d5576429cb2eb05b8c984fa7f06bb
data/README.md CHANGED
@@ -87,7 +87,7 @@ The queue latency is the time between when the job was enqueued and when it was
87
87
  filter environment = "production"
88
88
  filter level = "info"
89
89
  filter metric = "sidekiq.queue.latency"
90
- timechart duration:avg(duration), group_by(name)
90
+ timechart latency:avg(metric_amount/1000), group_by(string(named_tags.queue))
91
91
  ~~~
92
92
 
93
93
  * http://github.com/reidmorrison/rails_semantic_logger
@@ -100,8 +100,12 @@ For complete documentation see: https://logger.rocketjob.io/rails
100
100
 
101
101
  Rails Semantic Logger now supports Sidekiq metrics.
102
102
  Below are the metrics that are now available when the JSON logging format is used:
103
- - `sidekiq.job.perform` - The duration of each Sidekiq job.
104
- - `sidekiq.queue.latency` - The time between when a Sidekiq job was enqueued and when it was started.
103
+ - `sidekiq.job.perform`
104
+ - The duration of each Sidekiq job.
105
+ - `duration` contains the time in milliseconds that the job took to run.
106
+ - `sidekiq.queue.latency`
107
+ - The time between when a Sidekiq job was enqueued and when it was started.
108
+ - `metric_amount` contains the time in milliseconds that the job was waiting in the queue.
105
109
 
106
110
  ## Upgrading to Semantic Logger v4.15 & V4.16 - Sidekiq Support
107
111
 
@@ -108,12 +108,31 @@ module RailsSemanticLogger
108
108
  Resque.logger = SemanticLogger[Resque] if defined?(Resque) && Resque.respond_to?(:logger=)
109
109
 
110
110
  # Replace the Sidekiq logger
111
- if defined?(Sidekiq)
112
- if Sidekiq.respond_to?(:logger=)
113
- Sidekiq.logger = SemanticLogger[Sidekiq]
114
- elsif Sidekiq::VERSION[0..1] == "7."
115
- method = Sidekiq.server? ? :configure_server : :configure_client
116
- Sidekiq.public_send(method) { |cfg| cfg.logger = SemanticLogger[Sidekiq] }
111
+ if defined?(::Sidekiq)
112
+ ::Sidekiq.configure_client do |config|
113
+ config.logger = ::SemanticLogger[::Sidekiq]
114
+ end
115
+
116
+ ::Sidekiq.configure_server do |config|
117
+ config.logger = ::SemanticLogger[::Sidekiq]
118
+ if config.respond_to?(:options)
119
+ config.options[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
120
+ else
121
+ config[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
122
+ end
123
+
124
+ # Add back the default console logger unless already added
125
+ SemanticLogger.add_appender(io: $stdout, formatter: :color) unless SemanticLogger.appenders.console_output?
126
+
127
+ # Replace default error handler when present
128
+ existing = RailsSemanticLogger::Sidekiq::Defaults.delete_default_error_handler(config.error_handlers)
129
+ config.error_handlers << RailsSemanticLogger::Sidekiq::Defaults::ERROR_HANDLER if existing
130
+ end
131
+
132
+ if defined?(::Sidekiq::Job) && (::Sidekiq::VERSION.to_i != 5)
133
+ ::Sidekiq::Job.singleton_class.prepend(RailsSemanticLogger::Sidekiq::Loggable)
134
+ else
135
+ ::Sidekiq::Worker.singleton_class.prepend(RailsSemanticLogger::Sidekiq::Loggable)
117
136
  end
118
137
  end
119
138
 
@@ -154,7 +173,7 @@ module RailsSemanticLogger
154
173
 
155
174
  if config.rails_semantic_logger.semantic
156
175
  # Active Job
157
- if defined?(::ActiveJob) && defined?(::ActiveJob::Logging::LogSubscriber)
176
+ if defined?(::ActiveJob::Logging::LogSubscriber)
158
177
  RailsSemanticLogger.swap_subscriber(
159
178
  ::ActiveJob::Logging::LogSubscriber,
160
179
  RailsSemanticLogger::ActiveJob::LogSubscriber,
@@ -162,7 +181,7 @@ module RailsSemanticLogger
162
181
  )
163
182
  end
164
183
 
165
- if defined?(::ActiveJob) && defined?(::ActiveJob::LogSubscriber)
184
+ if defined?(::ActiveJob::LogSubscriber)
166
185
  RailsSemanticLogger.swap_subscriber(
167
186
  ::ActiveJob::LogSubscriber,
168
187
  RailsSemanticLogger::ActiveJob::LogSubscriber,
@@ -1,89 +1,14 @@
1
1
  # Sidekiq patches
2
- #
3
- # To re-enable stdout logging for sidekiq server processes, add the following snippet to config/initializers/sidekiq.rb:
4
- # Sidekiq.configure_server do |config|
5
- # SemanticLogger.add_appender(io: $stdout, level: :debug, formatter: :color)
6
- # end
7
2
  if Sidekiq::VERSION.to_i == 4
8
- require "sidekiq/exception_handler"
9
3
  require "sidekiq/logging"
10
4
  require "sidekiq/middleware/server/logging"
11
5
  require "sidekiq/processor"
12
- require "sidekiq/worker"
13
6
  elsif Sidekiq::VERSION.to_i == 5
14
- require "sidekiq/exception_handler"
15
- require "sidekiq/job_logger"
16
7
  require "sidekiq/logging"
17
- require "sidekiq/worker"
18
- elsif Sidekiq::VERSION.to_i == 6 && Sidekiq::VERSION.to_f < 6.5
19
- require "sidekiq/exception_handler"
20
- require "sidekiq/job_logger"
21
- require "sidekiq/worker"
22
- elsif Sidekiq::VERSION.to_i == 6
23
- require "sidekiq/job_logger"
24
- require "sidekiq/worker"
25
- else
26
- require "sidekiq/config"
27
- require "sidekiq/job_logger"
28
- require "sidekiq/job"
29
8
  end
30
9
 
31
10
  module Sidekiq
32
- # Sidekiq > v4
33
- if defined?(::Sidekiq::JobLogger)
34
- # Let Semantic Logger handle duration logging
35
- class JobLogger
36
- def call(item, queue, &block)
37
- klass = item["wrapped"] || item["class"]
38
- logger = klass ? SemanticLogger[klass] : Sidekiq.logger
39
-
40
- SemanticLogger.tagged(queue: queue) do
41
- # Latency is the time between when the job was enqueued and when it started executing.
42
- logger.info(
43
- "Start #perform",
44
- metric: "sidekiq.queue.latency",
45
- metric_amount: job_latency_ms(item)
46
- )
47
-
48
- # Measure the duration of running the job
49
- logger.measure_info(
50
- "Completed #perform",
51
- on_exception_level: :error,
52
- log_exception: :full,
53
- metric: "sidekiq.job.perform",
54
- &block
55
- )
56
- end
57
- end
58
-
59
- def prepare(job_hash, &block)
60
- level = job_hash["log_level"]
61
- if level
62
- SemanticLogger.silence(level) do
63
- SemanticLogger.tagged(job_hash_context(job_hash), &block)
64
- end
65
- else
66
- SemanticLogger.tagged(job_hash_context(job_hash), &block)
67
- end
68
- end
69
-
70
- def job_hash_context(job_hash)
71
- h = {jid: job_hash["jid"]}
72
- h[:bid] = job_hash["bid"] if job_hash["bid"]
73
- h[:tags] = job_hash["tags"] if job_hash["tags"]
74
- h[:queue] = job_hash["queue"] if job_hash["queue"]
75
- h
76
- end
77
-
78
- def job_latency_ms(job)
79
- return unless job && job["enqueued_at"]
80
-
81
- (Time.now.to_f - job["enqueued_at"].to_f) * 1000
82
- end
83
- end
84
- end
85
-
86
- # Sidekiq <= v6
11
+ # Sidekiq v4 & v5
87
12
  if defined?(::Sidekiq::Logging)
88
13
  # Replace Sidekiq logging context
89
14
  module Logging
@@ -100,106 +25,8 @@ module Sidekiq
100
25
  end
101
26
  end
102
27
 
103
- # Exception is already logged by Semantic Logger during the perform call
104
- if defined?(::Sidekiq::ExceptionHandler)
105
- # Sidekiq <= v6.5
106
- module ExceptionHandler
107
- class Logger
108
- def call(_exception, ctx)
109
- return if ctx.empty?
110
-
111
- job_hash = ctx[:job] || {}
112
- klass = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
113
- logger = klass ? SemanticLogger[klass] : Sidekiq.logger
114
- ctx[:context] ? logger.warn(ctx[:context], ctx) : logger.warn(ctx)
115
- end
116
- end
117
- end
118
- elsif defined?(::Sidekiq::Config)
119
- # Sidekiq >= v7
120
- class Config
121
- remove_const :ERROR_HANDLER
122
-
123
- ERROR_HANDLER = ->(ex, ctx, cfg = Sidekiq.default_configuration) do
124
- unless ctx.empty?
125
- job_hash = ctx[:job] || {}
126
- klass = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
127
- logger = klass ? SemanticLogger[klass] : Sidekiq.logger
128
- ctx[:context] ? logger.warn(ctx[:context], ctx) : logger.warn(ctx)
129
- end
130
- end
131
- end
132
- else
133
- # Sidekiq >= 6.5
134
- Sidekiq.error_handlers.delete(Sidekiq::DEFAULT_ERROR_HANDLER)
135
- Sidekiq.error_handlers << ->(ex, ctx) do
136
- unless ctx.empty?
137
- job_hash = ctx[:job] || {}
138
- klass = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
139
- logger = klass ? SemanticLogger[klass] : Sidekiq.logger
140
- ctx[:context] ? logger.warn(ctx[:context], ctx) : logger.warn(ctx)
141
- end
142
- end
143
- end
144
-
145
- # Logging within each worker should use its own logger
146
- case Sidekiq::VERSION.to_i
147
- when 4
148
- module Worker
149
- def self.included(base)
150
- if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
151
- raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}"
152
- end
153
-
154
- base.extend(ClassMethods)
155
- base.include(SemanticLogger::Loggable)
156
- base.class_attribute :sidekiq_options_hash
157
- base.class_attribute :sidekiq_retry_in_block
158
- base.class_attribute :sidekiq_retries_exhausted_block
159
- end
160
- end
161
- when 5
162
- module Worker
163
- def self.included(base)
164
- if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
165
- raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}"
166
- end
167
-
168
- base.extend(ClassMethods)
169
- base.include(SemanticLogger::Loggable)
170
- base.sidekiq_class_attribute :sidekiq_options_hash
171
- base.sidekiq_class_attribute :sidekiq_retry_in_block
172
- base.sidekiq_class_attribute :sidekiq_retries_exhausted_block
173
- end
174
- end
175
- when 6
176
- module Worker
177
- def self.included(base)
178
- if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
179
- raise ArgumentError, "Sidekiq::Worker cannot be included in an ActiveJob: #{base.name}"
180
- end
181
-
182
- base.include(Options)
183
- base.extend(ClassMethods)
184
- base.include(SemanticLogger::Loggable)
185
- end
186
- end
187
- else
188
- module Job
189
- def self.included(base)
190
- if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
191
- raise ArgumentError, "Sidekiq::Job cannot be included in an ActiveJob: #{base.name}"
192
- end
193
-
194
- base.include(Options)
195
- base.extend(ClassMethods)
196
- base.include(SemanticLogger::Loggable)
197
- end
198
- end
199
- end
200
-
28
+ # Sidekiq v4
201
29
  if defined?(::Sidekiq::Middleware::Server::Logging)
202
- # Sidekiq v4
203
30
  # Convert string to machine readable format
204
31
  class Processor
205
32
  def log_context(job_hash)
@@ -214,6 +41,7 @@ module Sidekiq
214
41
  module Middleware
215
42
  module Server
216
43
  class Logging
44
+ # rubocop:disable Style/ExplicitBlockArgument
217
45
  def call(worker, item, queue)
218
46
  SemanticLogger.tagged(queue: queue) do
219
47
  worker.logger.info(
@@ -0,0 +1,40 @@
1
+ module RailsSemanticLogger
2
+ module Sidekiq
3
+ module Defaults
4
+ # Prevent exception logging during standard error handling since the Job Logger below already logs the exception.
5
+ ERROR_HANDLER =
6
+ if ::Sidekiq::VERSION.to_f < 7.1 ||
7
+ (::Sidekiq::VERSION.to_f == 7.1 && ::Sidekiq::VERSION.split(".").last.to_i < 6)
8
+ lambda do |_ex, ctx|
9
+ unless ctx.empty?
10
+ job_hash = ctx[:job] || {}
11
+ klass = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
12
+ logger = klass ? SemanticLogger[klass] : Sidekiq.logger
13
+ ctx[:context] ? logger.warn(ctx[:context], ctx) : logger.warn(ctx)
14
+ end
15
+ end
16
+ else
17
+ lambda do |_ex, ctx, _default_configuration|
18
+ unless ctx.empty?
19
+ job_hash = ctx[:job] || {}
20
+ klass = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
21
+ logger = klass ? SemanticLogger[klass] : Sidekiq.logger
22
+ ctx[:context] ? logger.warn(ctx[:context], ctx) : logger.warn(ctx)
23
+ end
24
+ end
25
+ end
26
+
27
+ # Returns the default logger after removing from the supplied list.
28
+ # Returns [nil] when the default logger was not present.
29
+ def self.delete_default_error_handler(error_handlers)
30
+ return error_handlers.delete(::Sidekiq::Config::ERROR_HANDLER) if defined?(::Sidekiq::Config::ERROR_HANDLER)
31
+ return error_handlers.delete(::Sidekiq::DEFAULT_ERROR_HANDLER) if defined?(::Sidekiq::DEFAULT_ERROR_HANDLER)
32
+
33
+ return unless defined?(::Sidekiq::ExceptionHandler)
34
+
35
+ existing = error_handlers.find { |handler| handler.is_a?(::Sidekiq::ExceptionHandler::Logger) }
36
+ error_handlers.delete(existing) if existing
37
+ end
38
+ end
39
+ end
40
+ end
@@ -0,0 +1,59 @@
1
+ module RailsSemanticLogger
2
+ module Sidekiq
3
+ class JobLogger
4
+ # Sidekiq 6.5 does not take any arguments, whereas v7 is given a logger
5
+ def initialize(*_args)
6
+ end
7
+
8
+ def call(item, queue, &block)
9
+ klass = item["wrapped"] || item["class"]
10
+ logger = klass ? SemanticLogger[klass] : Sidekiq.logger
11
+
12
+ SemanticLogger.tagged(queue: queue) do
13
+ # Latency is the time between when the job was enqueued and when it started executing.
14
+ logger.info(
15
+ "Start #perform",
16
+ metric: "sidekiq.queue.latency",
17
+ metric_amount: job_latency_ms(item)
18
+ )
19
+
20
+ # Measure the duration of running the job
21
+ logger.measure_info(
22
+ "Completed #perform",
23
+ on_exception_level: :error,
24
+ log_exception: :full,
25
+ metric: "sidekiq.job.perform",
26
+ &block
27
+ )
28
+ end
29
+ end
30
+
31
+ def prepare(job_hash, &block)
32
+ level = job_hash["log_level"]
33
+ if level
34
+ SemanticLogger.silence(level) do
35
+ SemanticLogger.tagged(job_hash_context(job_hash), &block)
36
+ end
37
+ else
38
+ SemanticLogger.tagged(job_hash_context(job_hash), &block)
39
+ end
40
+ end
41
+
42
+ private
43
+
44
+ def job_hash_context(job_hash)
45
+ h = {jid: job_hash["jid"]}
46
+ h[:bid] = job_hash["bid"] if job_hash["bid"]
47
+ h[:tags] = job_hash["tags"] if job_hash["tags"]
48
+ h[:queue] = job_hash["queue"] if job_hash["queue"]
49
+ h
50
+ end
51
+
52
+ def job_latency_ms(job)
53
+ return unless job && job["enqueued_at"]
54
+
55
+ (Time.now.to_f - job["enqueued_at"].to_f) * 1000
56
+ end
57
+ end
58
+ end
59
+ end
@@ -0,0 +1,10 @@
1
+ module RailsSemanticLogger
2
+ module Sidekiq
3
+ module Loggable
4
+ def included(base)
5
+ super
6
+ base.include(SemanticLogger::Loggable)
7
+ end
8
+ end
9
+ end
10
+ end
@@ -1,3 +1,3 @@
1
1
  module RailsSemanticLogger
2
- VERSION = "4.16.0".freeze
2
+ VERSION = "4.17.0".freeze
3
3
  end
@@ -31,6 +31,12 @@ module RailsSemanticLogger
31
31
  autoload :Plugin, "rails_semantic_logger/delayed_job/plugin"
32
32
  end
33
33
 
34
+ module Sidekiq
35
+ autoload :Defaults, "rails_semantic_logger/sidekiq/defaults"
36
+ autoload :JobLogger, "rails_semantic_logger/sidekiq/job_logger"
37
+ autoload :Loggable, "rails_semantic_logger/sidekiq/loggable"
38
+ end
39
+
34
40
  autoload :Options, "rails_semantic_logger/options"
35
41
 
36
42
  # Swap an existing subscriber with a new one
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: rails_semantic_logger
3
3
  version: !ruby/object:Gem::Version
4
- version: 4.16.0
4
+ version: 4.17.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Reid Morrison
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2024-07-01 00:00:00.000000000 Z
11
+ date: 2024-07-05 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: rack
@@ -44,14 +44,14 @@ dependencies:
44
44
  requirements:
45
45
  - - "~>"
46
46
  - !ruby/object:Gem::Version
47
- version: '4.13'
47
+ version: '4.16'
48
48
  type: :runtime
49
49
  prerelease: false
50
50
  version_requirements: !ruby/object:Gem::Requirement
51
51
  requirements:
52
52
  - - "~>"
53
53
  - !ruby/object:Gem::Version
54
- version: '4.13'
54
+ version: '4.16'
55
55
  description:
56
56
  email:
57
57
  executables: []
@@ -85,6 +85,9 @@ files:
85
85
  - lib/rails_semantic_logger/extensions/sidekiq/sidekiq.rb
86
86
  - lib/rails_semantic_logger/options.rb
87
87
  - lib/rails_semantic_logger/rack/logger.rb
88
+ - lib/rails_semantic_logger/sidekiq/defaults.rb
89
+ - lib/rails_semantic_logger/sidekiq/job_logger.rb
90
+ - lib/rails_semantic_logger/sidekiq/loggable.rb
88
91
  - lib/rails_semantic_logger/version.rb
89
92
  homepage: https://logger.rocketjob.io
90
93
  licenses:
@@ -92,7 +95,7 @@ licenses:
92
95
  metadata:
93
96
  bug_tracker_uri: https://github.com/reidmorrison/rails_semantic_logger/issues
94
97
  documentation_uri: https://logger.rocketjob.io
95
- source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v4.16.0
98
+ source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v4.17.0
96
99
  rubygems_mfa_required: 'true'
97
100
  post_install_message:
98
101
  rdoc_options: []