semantic_logger 4.3.1 → 4.4.0

data/test/formatters/one_line_test.rb

@@ -1,60 +0,0 @@
-require_relative '../test_helper'
-
-module SemanticLogger
-  module Formatters
-    class DefaultTest < Minitest::Test
-      describe Default do
-        let(:log_time) do
-          Time.utc(2017, 1, 14, 8, 32, 5.375276)
-        end
-
-        let(:level) do
-          :debug
-        end
-
-        let(:log) do
-          log      = SemanticLogger::Log.new('DefaultTest', level)
-          log.time = log_time
-          log
-        end
-
-        let(:set_exception) do
-          begin
-            raise 'Oh no'
-          rescue Exception => exc
-            log.exception = exc
-          end
-        end
-
-        let(:formatter) do
-          formatter = SemanticLogger::Formatters::OneLine.new
-          # Does not use the logger instance for formatting purposes
-          formatter.call(log, nil)
-          formatter
-        end
-
-        describe 'message' do
-          it 'logs message' do
-            log.message = "Hello \nWorld\n"
-            assert_equal '-- Hello World', formatter.message
-          end
-
-          it 'skips empty message' do
-            refute formatter.message
-          end
-        end
-
-        describe 'exception' do
-          it 'logs exception' do
-            set_exception
-            assert_equal '-- Exception: RuntimeError: Oh no', formatter.exception
-          end
-
-          it 'skips nil exception' do
-            refute formatter.exception
-          end
-        end
-      end
-    end
-  end
-end

data/test/formatters/signalfx_test.rb

@@ -1,197 +0,0 @@
-require_relative '../test_helper'
-require 'net/http'
-
-module SemanticLogger
-  module Formatters
-    class SignalfxTest < Minitest::Test
-      describe SemanticLogger::Formatters::Signalfx do
-        let :average_metric_name do
-          'Application.average'
-        end
-
-        let :counter_metric_name do
-          'Application.counter'
-        end
-
-        let :log do
-          metric     = '/user/login'
-          log        = SemanticLogger::Log.new('User', :debug)
-          log.metric = metric
-          log
-        end
-
-        let :logs do
-          3.times.collect do |i|
-            l        = log.dup
-            l.metric = "/user/login#{i + 1}"
-            l
-          end
-        end
-
-        let :same_logs do
-          3.times.collect do |_i|
-            l        = log.dup
-            l.metric = '/user/login'
-            l
-          end
-        end
-
-        let :dimensions do
-          {action: 'hit', user: 'jbloggs', state: 'FL'}
-        end
-
-        let :all_dimensions do
-          dims        = dimensions.merge(
-            host:        SemanticLogger.host,
-            application: SemanticLogger.application,
-            environment: 'test'
-          )
-          string_keys = {}
-          dims.each_pair { |k, v| string_keys[k.to_s] = v }
-          string_keys
-        end
-
-        let :appender do
-          Net::HTTP.stub_any_instance(:start, true) do
-            SemanticLogger::Metric::Signalfx.new(token: 'TEST')
-          end
-        end
-
-        let :formatter do
-          appender.formatter
-        end
-
-        describe 'format single log' do
-          let :result do
-            JSON.parse(formatter.call(log, appender))
-          end
-
-          it 'send counter metric when there is no duration' do
-            hash = result
-            assert counters = hash['counter'], hash
-            assert counter = counters.first, hash
-            assert_equal counter_metric_name, counter['metric'], counter
-            assert_equal 1, counter['value'], counter
-            assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
-            assert counter.key?('dimensions')
-          end
-
-          it 'send gauge metric when log includes duration' do
-            log.duration = 1234
-            hash         = result
-            assert counters = hash['gauge'], hash
-            assert counter = counters.first, hash
-            assert_equal average_metric_name, counter['metric'], counter
-            assert_equal 1234, counter['value'], counter
-            assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
-            assert counter.key?('dimensions')
-          end
-
-          it 'also sends counter metric when gauge metric is sent' do
-            log.duration = 1234
-            hash         = result
-            assert counters = hash['counter'], hash
-            assert counter = counters.first, hash
-            assert_equal counter_metric_name, counter['metric'], counter
-            assert_equal 1, counter['value'], counter
-            assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
-            assert counter.key?('dimensions')
-          end
-
-          it 'only forwards whitelisted dimensions from named_tags' do
-            log.named_tags       = {user_id: 47, tracking_number: 7474, session_id: 'hsdhngsd'}
-            formatter.dimensions = %i[user_id application]
-            hash                 = result
-            assert counters = hash['counter'], hash
-            assert counter = counters.first, hash
-            assert_equal({'class' => 'user', 'action' => 'login', 'environment' => 'test', 'user_id' => '47', 'host' => SemanticLogger.host, 'application' => SemanticLogger.application}, counter['dimensions'], counter)
-          end
-
-          it 'raises exception with both a whitelist and blacklist' do
-            assert_raises ArgumentError do
-              SemanticLogger::Formatters::Signalfx.new(token: 'TEST', dimensions: [:user_id], exclude_dimensions: [:tracking_number])
-            end
-          end
-
-          it 'send custom counter metric when there is no duration' do
-            log.metric     = 'Filter/count'
-            log.dimensions = dimensions
-            hash           = result
-
-            assert counters = hash['counter'], hash
-            assert counter = counters.first, hash
-            assert_equal 'Filter.count', counter['metric'], counter
-            assert_equal 1, counter['value'], counter
-            assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
-            assert_equal all_dimensions, counter['dimensions']
-          end
-        end
-
-        describe 'format batch logs' do
-          let :result do
-            JSON.parse(formatter.batch(logs, appender))
-          end
-
-          it 'send metrics' do
-            hash = result
-
-            assert counters = hash['counter'], hash
-            assert_equal 3, counters.size
-            assert_equal counter_metric_name, counters[0]['metric']
-            assert_equal 1, counters[0]['value']
-            assert_equal counter_metric_name, counters[1]['metric']
-            assert_equal counter_metric_name, counters[2]['metric']
-          end
-
-          it 'sends gauge metrics' do
-            logs.each { |log| log.duration = 3.5 }
-            hash = result
-            assert gauges = hash['gauge'], hash
-            assert_equal 3, gauges.size
-            assert_equal average_metric_name, gauges[0]['metric']
-            assert_equal 3.5, gauges[0]['value']
-            assert_equal average_metric_name, gauges[1]['metric']
-            assert_equal average_metric_name, gauges[2]['metric']
-          end
-
-          describe 'send custom' do
-            let :logs do
-              3.times.collect do |_i|
-                l            = log.dup
-                l.metric     = 'Filter/count'
-                l.dimensions = dimensions
-                l
-              end
-            end
-
-            it 'counter metric when there is no duration' do
-              hash = result
-
-              assert counters = hash['counter'], hash
-              assert counter = counters.first, hash
-              assert_equal 'Filter.count', counter['metric'], counter
-              assert_equal 3, counter['value'], counter
-              assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
-              assert_equal all_dimensions, counter['dimensions']
-            end
-          end
-        end
-
-        describe 'format batch logs with aggregation' do
-          let :result do
-            JSON.parse(formatter.batch(same_logs, appender))
-          end
-
-          it 'sends counter metrics' do
-            hash = result
-
-            assert counters = hash['counter'], hash
-            assert_equal 1, counters.size
-            assert_equal counter_metric_name, counters[0]['metric']
-            assert_equal 3, counters[0]['value']
-          end
-        end
-      end
-    end
-  end
-end

data/test/formatters_test.rb

@@ -1,36 +0,0 @@
-require_relative 'test_helper'
-
-class FormattersTest < Minitest::Test
-  describe SemanticLogger::Formatters do
-    describe '.factory' do
-      let :log do
-        SemanticLogger::Log.new('Test', :info)
-      end
-
-      let :appender do
-        SemanticLogger::Appender::File.new(io: STDOUT)
-      end
-
-      it 'from a symbol' do
-        assert formatter = SemanticLogger::Formatters.factory(:raw)
-        assert formatter.is_a?(SemanticLogger::Formatters::Raw)
-        assert_equal 'Test', formatter.call(log, appender)[:name]
-      end
-
-      it 'from a Hash (Symbol with options)' do
-        assert formatter = SemanticLogger::Formatters.factory(raw: {time_format: '%Y%m%d'})
-        assert formatter.is_a?(SemanticLogger::Formatters::Raw)
-        assert result = formatter.call(log, appender)
-        assert_equal 'Test', result[:name]
-        assert_equal Time.now.strftime('%Y%m%d'), result[:time]
-      end
-
-      it 'from block' do
-        my_formatter = ->(log, _appender) { log.name }
-        assert formatter = SemanticLogger::Formatters.factory(my_formatter)
-        assert formatter.is_a?(Proc)
-        assert_equal 'Test', formatter.call(log, appender)
-      end
-    end
-  end
-end

data/test/in_memory_appender.rb

@@ -1,8 +0,0 @@
-# Store in memory the last log message received.
-class InMemoryAppender < SemanticLogger::Subscriber
-  attr_accessor :message
-
-  def log(log)
-    self.message = log
-  end
-end

data/test/in_memory_appender_helper.rb

@@ -1,43 +0,0 @@
-require 'minitest/shared_description'
-
-InMemoryAppenderHelper = shared_description do
-  let :log_message do
-    SemanticLogger.flush
-    appender.message
-  end
-
-  let :appender do
-    InMemoryAppender.new
-  end
-
-  let :thread_name do
-    Thread.current.name
-  end
-
-  let :payload do
-    {session_id: 'HSSKLEU@JDK767', tracking_number: 12_345}
-  end
-
-  let :logger do
-    SemanticLogger['TestLogger']
-  end
-
-  let :appender_options do
-    {appender: appender}
-  end
-
-  let :added_appender do
-    SemanticLogger.add_appender(appender_options)
-  end
-
-  before do
-    SemanticLogger.default_level   = :trace
-    SemanticLogger.backtrace_level = :trace
-    SemanticLogger.flush
-    added_appender
-  end
-
-  after do
-    SemanticLogger.appenders.each { |appender| SemanticLogger.remove_appender(appender) }
-  end
-end

data/test/in_memory_batch_appender.rb

@@ -1,8 +0,0 @@
-# Store in memory the last log message received.
-class InMemoryBatchAppender < SemanticLogger::Subscriber
-  attr_accessor :message
-
-  def batch(logs)
-    self.message = logs
-  end
-end

data/test/in_memory_metrics_appender.rb

@@ -1,13 +0,0 @@
-# Store in memory the last log message received.
-class InMemoryMetricsAppender < SemanticLogger::Subscriber
-  attr_accessor :message
-
-  def log(log)
-    self.message = log
-  end
-
-  # Only forward log entries that contain metrics.
-  def should_log?(log)
-    log.metric && meets_log_level?(log) && !filtered?(log)
-  end
-end

data/test/loggable_test.rb

@@ -1,103 +0,0 @@
-require_relative 'test_helper'
-require 'stringio'
-
-class TestAttribute
-  include SemanticLogger::Loggable
-end
-
-# Unit Test for SemanticLogger::Appender::File
-#
-class AppenderFileTest < Minitest::Test
-  module Perform
-    def perform
-      logger.info 'perform'
-    end
-  end
-
-  class Base
-    include SemanticLogger::Loggable
-    include Perform
-  end
-
-  module Process
-    def process
-      logger.info 'process'
-    end
-  end
-
-  class Subclass < Base
-    include Process
-  end
-
-  describe SemanticLogger::Loggable do
-    describe 'inheritance' do
-      it 'should give child classes their own logger' do
-        assert_equal Subclass.name, Subclass.logger.name
-        assert_equal Base.name, Base.logger.name
-        assert_equal Subclass.name, Subclass.logger.name
-        child_logger = Subclass.logger
-        refute_equal child_logger, Base.logger
-        assert_equal child_logger.object_id, Subclass.logger.object_id
-      end
-
-      it 'should give child objects their own logger' do
-        subclass = Subclass.new
-        base     = Base.new
-        assert_equal subclass.class.name, subclass.logger.name
-        assert_equal base.class.name, base.logger.name
-        assert_equal subclass.class.name, subclass.logger.name
-        child_logger = subclass.logger
-        refute_equal child_logger, base.logger
-        assert_equal child_logger.object_id, subclass.logger.object_id
-      end
-
-      it 'should allow mixins to call parent logger' do
-        base = Base.new
-        base.perform
-        called = false
-        Base.logger.stub(:info, ->(description) { called = true if description == 'perform' }) do
-          base.perform
-        end
-        assert called, 'Did not call the correct logger'
-      end
-
-      it 'should allow child mixins to call parent logger' do
-        subclass = Subclass.new
-        subclass.process
-        called = false
-        Subclass.logger.stub(:info, ->(description) { called = true if description == 'process' }) do
-          subclass.process
-        end
-        assert called, 'Did not call the correct logger'
-      end
-    end
-
-    describe 'logger' do
-      include InMemoryAppenderHelper
-
-      describe 'for each log level' do
-        # Ensure that any log level can be logged
-        SemanticLogger::LEVELS.each do |level|
-          it "logs #{level} information with class attribute" do
-            TestAttribute.logger.send(level, "hello #{level}", payload)
-
-            assert log = log_message
-            assert_equal "hello #{level}", log.message
-            assert_equal level, log.level
-            assert_equal 'TestAttribute', log.name
-            assert_equal payload, log.payload
-          end
-
-          it "log #{level} information with instance attribute" do
-            TestAttribute.new.logger.send(level, "hello #{level}", payload)
-            assert log = log_message
-            assert_equal "hello #{level}", log.message
-            assert_equal level, log.level
-            assert_equal 'TestAttribute', log.name
-            assert_equal payload, log.payload
-          end
-        end
-      end
-    end
-  end
-end