loga 2.8.0 → 2.9.0

data/spec/integration/sidekiq8_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Sidekiq client logger' do
+  let(:target) { StringIO.new }
+  let(:config) { Sidekiq.instance_variable_get :@config }
+
+  before do
+    Sidekiq.configure_server do |config|
+      config.redis = { pool_name: :default }
+    end
+
+    Loga.reset
+
+    Loga.configure(
+      service_name: 'hello_world_app',
+      service_version: '1.0',
+      device: target,
+      format: :gelf,
+    )
+  end
+
+  it 'has the proper job logger' do
+    expect(config[:job_logger]).to eq Loga::Sidekiq8::JobLogger
+  end
+
+  it 'has the proper logger for Sidekiq.logger' do
+    expect(Sidekiq.logger).to eq Loga.logger
+  end
+
+  context 'with processor' do
+    require 'sidekiq/processor'
+
+    let(:mutex) { Mutex.new }
+    let(:cond) { ConditionVariable.new }
+    let(:processor) do
+      Sidekiq::Processor.new(config.default_capsule) { |pr, ex| result(pr, ex) }
+    end
+
+    before do
+      @exception = nil
+    end
+
+    context 'with a successful job' do
+      before do
+        MySidekiqWorker.perform_async('Bob')
+
+        await { processor.start }
+
+        processor.terminate(true)
+      end
+
+      it 'logs the job processing event' do
+        test_log_from_worker(read_json_log(line: -2))
+      end
+
+      it 'logs the "done" event' do
+        test_job_end_log(read_json_log(line: -1))
+      end
+    end
+
+    context 'with an error' do
+      before do
+        MySidekiqWorker.perform_async('Boom')
+
+        await { processor.start }
+
+        processor.terminate(true)
+      end
+
+      it 'logs the "error" event' do
+        test_job_fail_log(read_json_log(line: 0))
+      end
+
+      it 're-throws the error' do
+        # rubocop:disable RSpec/InstanceVariable
+        expect(@exception.message).to eq('Boom')
+        # rubocop:enable RSpec/InstanceVariable
+      end
+    end
+
+    def result(_processor, exception)
+      @exception = exception
+      mutex.synchronize { cond.signal }
+    end
+
+    def await(timeout: 0.1)
+      mutex.synchronize do
+        yield
+        cond.wait(mutex, timeout)
+      end
+    end
+
+    def common_log_fields
+      {
+        '_class' => 'MySidekiqWorker',
+        '_service.name' => 'hello_world_app',
+        '_service.version' => '1.0',
+        '_tags' => '',
+        'version' => '1.1',
+      }.freeze
+    end
+
+    def job_logger_common_fields
+      common_log_fields.merge(
+        '_queue' => 'default',
+        '_retry' => true,
+        '_type' => 'sidekiq',
+      )
+    end
+
+    def test_log_from_worker(json_line)
+      aggregate_failures do
+        expect(json_line).to include(
+          common_log_fields.merge(
+            'level' => 6,
+            'short_message' => 'Hello from MySidekiqWorker',
+          ),
+        )
+
+        %w[_jid timestamp host].each do |key|
+          expect(json_line).to have_key(key)
+        end
+
+        expect(json_line).not_to include('_duration')
+      end
+    end
+
+    def test_job_end_log(json_line)
+      aggregate_failures do
+        expect(json_line).to include(
+          job_logger_common_fields.merge(
+            '_params' => ['Bob'],
+            'level' => 6,
+          ),
+        )
+
+        %w[_created_at _enqueued_at _jid _duration timestamp host].each do |key|
+          expect(json_line).to have_key(key)
+        end
+
+        expect(json_line['_duration']).to be < 500
+        expect(json_line['short_message'])
+          .to match(/MySidekiqWorker with jid: '\w+' done/)
+      end
+    end
+
+    def test_job_fail_log(json_line)
+      aggregate_failures do
+        expect(json_line).to include(
+          job_logger_common_fields.merge(
+            '_params' => ['Boom'],
+            'level' => 4,
+          ),
+        )
+
+        %w[_created_at _enqueued_at _jid _duration timestamp host].each do |key|
+          expect(json_line).to have_key(key)
+        end
+
+        expect(json_line['_duration']).to be < 500
+        expect(json_line['short_message'])
+          .to match(/MySidekiqWorker with jid: '\w+' fail/)
+      end
+    end
+  end
+
+  def dump_log
+    offset = target.pos
+
+    target.rewind
+    target.each_line { puts _1 }
+
+    target.pos = offset
+  end
+
+  def read_json_log(line:)
+    target.rewind
+
+    JSON.parse(target.readlines[line])
+  end
+end
+
+class MySidekiqWorker
+  include Sidekiq::Job
+
+  def perform(name)
+    raise name if name == 'Boom'
+
+    logger.info('Hello from MySidekiqWorker')
+  end
+end

data/spec/integration/sinatra_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class MySinatraApp < Sinatra::Base
@@ -21,7 +23,7 @@ class MySinatraApp < Sinatra::Base
   end
 end
 
-RSpec.describe 'Structured logging with Sinatra', :with_hostname, :timecop do
+RSpec.describe 'Structured logging with Sinatra', :timecop, :with_hostname do
   let(:io) { StringIO.new }
   let(:format) {}
   let(:last_log_entry) do
@@ -59,7 +61,7 @@ RSpec.describe 'Structured logging with Sinatra', :with_hostname, :timecop do
     end
   end
 
-  # rubocop:disable Metrics/LineLength
+  # rubocop:disable Layout/LineLength
   context 'when RACK_ENV is development', if: ENV['RACK_ENV'].eql?('development') do
     let(:format) { :simple }
     let(:last_log_entry) do
@@ -69,12 +71,12 @@ RSpec.describe 'Structured logging with Sinatra', :with_hostname, :timecop do
     let(:data) do
       {
         'method' => 'GET',
-        'path'   => '/ok',
+        'path' => '/ok',
         'params' => { 'username'=>'yoshi' },
         'request_id' => '700a6a01',
         'request_ip' => '127.0.0.1',
         'user_agent' => nil,
-        'duration'   => 0,
+        'duration' => 0,
         'status' => 200,
       }
     end
@@ -97,7 +99,7 @@ RSpec.describe 'Structured logging with Sinatra', :with_hostname, :timecop do
       let(:data) do
         super().merge(
           'status' => 302,
-          'path'   => '/new',
+          'path' => '/new',
           'params' => {},
         )
       end
@@ -112,16 +114,24 @@ RSpec.describe 'Structured logging with Sinatra', :with_hostname, :timecop do
       let(:data) do
         super().merge(
           'status' => 500,
-          'path'   => '/error',
+          'path' => '/error',
           'params' => {},
         )
       end
 
       it 'logs the request with the exception' do
         get '/error', {}, 'HTTP_X_REQUEST_ID' => '700a6a01'
-        expect(last_log_entry).to eql("E, #{time_pid_tags} GET /error 500 in 0ms type=request #{data_as_text} exception=undefined method `name' for nil:NilClass\n")
+
+        exception_line =
+          if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('3.4.0dev')
+            "E, #{time_pid_tags} GET /error 500 in 0ms type=request #{data_as_text} exception=undefined method 'name' for nil"
+          else
+            "E, #{time_pid_tags} GET /error 500 in 0ms type=request #{data_as_text} exception=undefined method `name' for nil"
+          end
+
+        expect(last_log_entry).to start_with(exception_line)
       end
     end
   end
-  # rubocop:enable Metrics/LineLength
+  # rubocop:enable Layout/LineLength
 end

data/spec/loga/sidekiq5/job_logger_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'loga/sidekiq5/job_logger'
 

data/spec/loga/sidekiq6/job_logger_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'loga/sidekiq6/job_logger'
 
@@ -24,7 +26,7 @@ RSpec.describe Loga::Sidekiq6::JobLogger do
 
   # https://github.com/mperham/sidekiq/blob/v6.1.2/lib/sidekiq/job_logger.rb
   it 'inherits from ::Sidekiq::JobLogger' do
-    expect(subject).to be_a(::Sidekiq::JobLogger)
+    expect(subject).to be_a(Sidekiq::JobLogger)
   end
 
   describe '#call' do

data/spec/loga/sidekiq_latest/job_logger_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'loga/sidekiq7/job_logger'
+require 'loga/sidekiq8/job_logger'
+
+logger_klass =
+  if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('8.0.0')
+    Loga::Sidekiq8::JobLogger
+  elsif Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('7.0.0')
+    Loga::Sidekiq7::JobLogger
+  else
+    raise 'No suitable Sidekiq JobLogger implementation found'
+  end
+
+RSpec.describe logger_klass, 'unified (latest) Sidekiq JobLogger spec' do
+  # Sidekiq < 7.3: initializer expects a raw logger
+  # Sidekiq >= 7.3: initializer expects a config object responding to #logger and #[] (Sidekiq 8 keeps this)
+  subject(:job_logger) do
+    if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('7.3.0')
+      described_class.new(sidekiq_config)
+    else
+      described_class.new(logger)
+    end
+  end
+
+  let(:target) { StringIO.new }
+
+  let(:json_line) do
+    target.rewind
+    raw = target.read
+    line = raw.split("\n").last
+    JSON.parse(line) if line
+  end
+
+  let(:logger) { Loga.logger }
+  let(:sidekiq_config) { instance_double(Sidekiq::Config, logger: logger, :[] => nil) }
+
+  before do
+    Loga.reset
+    Loga.configure(
+      service_name: 'hello_world_app',
+      service_version: '1.0',
+      device: target,
+      format: :gelf,
+    )
+  end
+
+  it 'inherits from ::Sidekiq::JobLogger' do
+    expect(job_logger).to be_a(Sidekiq::JobLogger)
+  end
+
+  describe '#call' do
+    let(:item_data) do
+      {
+        'class' => 'HardWorker',
+        'args' => ['asd'],
+        'retry' => true,
+        'queue' => 'default',
+        'jid' => '591f6f66ee0d218fb451dfb6',
+        'created_at' => 1_528_799_582.904939,
+        'enqueued_at' => 1_528_799_582.9049861,
+      }
+    end
+
+    context 'when the job passes successfully' do
+      it 'logs the expected structured event' do
+        job_logger.call(item_data, 'default') do
+          # simulate job body
+        end
+
+        expected = {
+          'version' => '1.1',
+          'level' => 6, # INFO -> 6 (syslog mapping)
+          '_type' => 'sidekiq',
+          '_created_at' => item_data['created_at'],
+          '_enqueued_at' => item_data['enqueued_at'],
+          '_jid' => item_data['jid'],
+          '_retry' => true,
+          '_queue' => 'default',
+          '_service.name' => 'hello_world_app',
+          '_service.version' => '1.0',
+          '_class' => 'HardWorker',
+          '_params' => ['asd'],
+          '_tags' => '',
+        }
+
+        aggregate_failures do
+          expect(json_line).to include(expected)
+          expect(json_line['_duration']).to be_a(Float).or be_a(Integer)
+          expect(json_line['timestamp']).to be_a(Float)
+          expect(json_line['host']).to be_a(String)
+          expect(json_line['short_message'])
+            .to match(/HardWorker with jid: '591f6f66ee0d218fb451dfb6' (done|executed)/)
+        end
+      end
+    end
+
+    context 'when the job fails' do
+      it 'logs the expected structured event with exception info' do
+        failing = lambda do
+          job_logger.call(item_data, 'default') do
+            raise StandardError, 'Boom'
+          end
+        end
+
+        expect(&failing).to raise_error(StandardError, 'Boom')
+
+        expected = {
+          'version' => '1.1',
+          # WARN -> syslog 4 (sidekiq job failure logged at warn)
+          'level' => 4,
+          '_type' => 'sidekiq',
+          '_created_at' => item_data['created_at'],
+          '_enqueued_at' => item_data['enqueued_at'],
+          '_jid' => item_data['jid'],
+          '_retry' => true,
+          '_queue' => 'default',
+          '_service.name' => 'hello_world_app',
+          '_service.version' => '1.0',
+          '_class' => 'HardWorker',
+          '_params' => ['asd'],
+          '_tags' => '',
+          '_exception' => 'Boom',
+        }
+
+        aggregate_failures do
+          expect(json_line).to include(expected)
+          expect(json_line['_duration']).to be_a(Float).or be_a(Integer)
+          expect(json_line['timestamp']).to be_a(Float)
+          expect(json_line['host']).to be_a(String)
+          expect(json_line['short_message'])
+            .to match(/HardWorker with jid: '591f6f66ee0d218fb451dfb6' fail/)
+        end
+      end
+    end
+  end
+end

data/spec/loga/sidekiq_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Loga::Sidekiq do
@@ -30,11 +32,23 @@ RSpec.describe Loga::Sidekiq do
 
         m = ENV['BUNDLE_GEMFILE'].match(/sidekiq(?<version>\d+)/)
 
+        job_logger =
+          if Sidekiq.respond_to?(:options)
+            Sidekiq.options[:job_logger]
+          else
+            sidekiq_config = Sidekiq.instance_variable_get(:@config)
+            sidekiq_config && sidekiq_config[:job_logger]
+          end
+
         case m['version']
         when '51'
-          expect(::Sidekiq.options[:job_logger]).to eq(Loga::Sidekiq5::JobLogger)
-        when '6'
-          expect(::Sidekiq.options[:job_logger]).to eq(Loga::Sidekiq6::JobLogger)
+          expect(job_logger).to eq(Loga::Sidekiq5::JobLogger)
+        when '6', '60', '61', '62', '63', '64', '65'
+          expect(job_logger).to eq(Loga::Sidekiq6::JobLogger)
+        when '7', '70', '71', '72', '73'
+          expect(job_logger).to eq(Loga::Sidekiq7::JobLogger)
+        when '8', '80'
+          expect(job_logger).to eq(Loga::Sidekiq8::JobLogger)
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'byebug'
 require 'pry'
 require 'support/gethostname_shared'
@@ -8,16 +10,17 @@ require 'rack/test'
 require 'simplecov'
 
 SimpleCov.start do
-  command_name "ruby-#{RUBY_VERSION}-#{File.basename(ENV['BUNDLE_GEMFILE'], '.gemfile')}"
+  command_name "ruby-#{RUBY_VERSION}-#{File.basename(ENV.fetch('BUNDLE_GEMFILE', nil),
+                                                     '.gemfile')}"
 
   # Exclude specs from showing up in the code coverage report.
   add_filter 'spec/'
 end
 
-case ENV['BUNDLE_GEMFILE']
+case ENV.fetch('BUNDLE_GEMFILE', nil)
 when /rails/
   rspec_pattern = 'integration/rails/**/*_spec.rb'
-  /(?<appraisal>rails\d{2})\.gemfile/ =~ ENV['BUNDLE_GEMFILE']
+  /(?<appraisal>rails\d{2})\.gemfile/ =~ ENV.fetch('BUNDLE_GEMFILE', nil)
   require 'rails'
   require 'action_mailer'
   require File.expand_path("../fixtures/#{appraisal}.rb",  __FILE__)
@@ -56,10 +59,16 @@ when /sidekiq(?<version>\d+)/
       'spec/loga/sidekiq6/**/*_spec.rb',
       'spec/loga/sidekiq_spec.rb',
     ].join(',')
-  when '7', '70', '71'
+  when '7', '70', '71', '72', '73'
     rspec_pattern = [
       'spec/integration/sidekiq7_spec.rb',
-      'spec/loga/sidekiq7/**/*_spec.rb',
+      'spec/loga/sidekiq_latest/**/*_spec.rb',
+      'spec/loga/sidekiq_spec.rb',
+    ].join(',')
+  when '8', '80'
+    rspec_pattern = [
+      'spec/integration/sidekiq8_spec.rb',
+      'spec/loga/sidekiq_latest/**/*_spec.rb',
       'spec/loga/sidekiq_spec.rb',
     ].join(',')
   else

data/spec/support/gethostname_shared.rb

@@ -1,4 +1,6 @@
-shared_context 'gethostname', with_hostname: true do
+# frozen_string_literal: true
+
+shared_context 'gethostname', :with_hostname do
   let(:hostname) { 'bird.example.com' }
 
   before do

data/spec/support/helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bigdecimal'
 
 module Helpers
@@ -16,4 +18,12 @@ module Helpers
     allow(loga).to receive(:logger).and_return(logger)
     loga
   end
+
+  def with_new_ruby(**data)
+    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.4')
+      data[:test]
+    else
+      data[:else]
+    end
+  end
 end