semantic_logger 3.3.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1332704e0667fa360e4b9a632e861fa75966f3e0
-  data.tar.gz: ad079a8ed4ce5fb1802594e845f38a523c0a1a09
+  metadata.gz: fc98e41e370bc6257e0399ae04f886147944e227
+  data.tar.gz: b09cc78d0efae6377959ee8db77d4b93a5d81c9d
 SHA512:
-  metadata.gz: 1c33e421728430664dba299821ceb31816dda9068c94f1cefbaecd3ce64b9b4cd9be16f6109bbd9ac52fbac38e935e46d4935f09088c7a1e508c4625704ad4da
-  data.tar.gz: c8199f834fdeee217a50ff07c682e3954c7b42bc2d48514af3f9fbbee698358eb59e5fd834d34b57f521437c8a6c785a575333abb4640a0814f043bdd386574b
+  metadata.gz: dcfe55e29af7219b978c73f1d9f3a5123f49cd0eafb69ebdfc859372f6adbc30636c3b02320fa739cfe68df7cafd6ad805866441b1873bfc72b0a2cbe43eb06c
+  data.tar.gz: 3c95e43452d9e018b629845ca29c5d445c0cf1518a53b8170cdf82975b19c48ea60cf796ef8d169cc47c14142e2e555c2c2793225be2715af8d87a526dfa7bea

data/README.md

@@ -38,10 +38,8 @@ instead of Semantic Logger directly since it will automatically replace the Rail
 ## Supports
 
 Semantic Logger is tested and supported on the following Ruby platforms:
-- Ruby 2.1 and above
-- JRuby 1.7 and above
-- JRuby 9.0 and above
-- Rubinius 2.5 and above
+- Ruby 2.1, 2.2, 2.3, and above
+- JRuby 1.7.23, 9.0.5 and above
 
 The following gems are only required when their corresponding appenders are being used,
 and are therefore not automatically included by this gem:

data/lib/semantic_logger.rb

@@ -31,6 +31,7 @@ module SemanticLogger
     autoload :File,             'semantic_logger/appender/file'
     autoload :Graylog,          'semantic_logger/appender/graylog'
     autoload :Honeybadger,      'semantic_logger/appender/honeybadger'
+    autoload :Sentry,           'semantic_logger/appender/sentry'
     autoload :Http,             'semantic_logger/appender/http'
     autoload :MongoDB,          'semantic_logger/appender/mongodb'
     autoload :NewRelic,         'semantic_logger/appender/new_relic'

data/lib/semantic_logger/appender/sentry.rb

@@ -0,0 +1,72 @@
+begin
+  require 'sentry-raven'
+rescue LoadError
+  raise 'Gem sentry-raven is required for logging purposes. Please add the gem "sentry-raven" to your Gemfile.'
+end
+
+# Send log messages to sentry
+#
+# Example:
+#   SemanticLogger.add_appender(appender: :sentry)
+#
+class SemanticLogger::Appender::Sentry < SemanticLogger::Subscriber
+  # Create Appender
+  #
+  # Parameters
+  #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+  #     Override the log level for this appender.
+  #     Default: :error
+  #
+  #   formatter: [Object|Proc|Symbol|Hash]
+  #     An instance of a class that implements #call, or a Proc to be used to format
+  #     the output from this appender
+  #     Default: Use the built-in formatter (See: #call)
+  #
+  #   filter: [Regexp|Proc]
+  #     RegExp: Only include log messages where the class name matches the supplied.
+  #     regular expression. All other messages will be ignored.
+  #     Proc: Only include log messages where the supplied Proc returns true
+  #           The Proc must return true or false.
+  #
+  #   host: [String]
+  #     Name of this host to appear in log messages.
+  #     Default: SemanticLogger.host
+  #
+  #   application: [String]
+  #     Name of this application to appear in log messages.
+  #     Default: SemanticLogger.application
+  def initialize(options = {}, &block)
+    options         = options.is_a?(Hash) ? options.dup : {level: options}
+    options[:level] ||= :error
+
+    super(options, &block)
+  end
+
+  # Send an error notification to sentry
+  def log(log)
+    return false unless should_log?(log)
+
+    context = formatter.call(log, self)
+    if log.exception
+      context.delete(:exception)
+      Raven.capture_exception(log.exception, context)
+    else
+      message = {
+        error_class:   context.delete(:name),
+        error_message: context.delete(:message),
+        extra: context
+      }
+      message[:backtrace] = log.backtrace if log.backtrace
+      Raven.capture_message(message[:error_message], message)
+    end
+    true
+  end
+
+  private
+
+  # Use Raw Formatter by default
+  def default_formatter
+    SemanticLogger::Formatters::Raw.new
+  end
+
+end

data/lib/semantic_logger/concerns/compatibility.rb

@@ -14,6 +14,8 @@ module SemanticLogger
           alias_method :unknown?, :error? # :nodoc:
 
           alias_method :<<, :info # :nodoc:
+          # Active Record's Session Store calls silence_logger
+          alias_method :silence_logger, :silence # :nodoc:
 
           alias_method :progname, :name # :nodoc:
           alias_method :progname=, :name= # :nodoc:

data/lib/semantic_logger/log.rb

@@ -232,6 +232,7 @@ module SemanticLogger
 
       # Metric
       h[:metric] = metric if metric
+      h[:metric_amount] = metric_amount if metric_amount
       h
     end
 

data/lib/semantic_logger/metrics/new_relic.rb

@@ -1,6 +1,6 @@
 module SemanticLogger
   module Metrics
-    class NewRelic < Subscriber
+    class NewRelic
       attr_accessor :prefix
 
       # Parameters:

data/lib/semantic_logger/metrics/statsd.rb

@@ -7,7 +7,7 @@ end
 
 module SemanticLogger
   module Metrics
-    class Statsd < Subscriber
+    class Statsd
       # Create Statsd metrics subscriber
       #
       # Parameters:
@@ -18,10 +18,6 @@ module SemanticLogger
       #     Example, send all metrics to a particular namespace:
       #       udp://localhost:8125/namespace
       #     Default: udp://localhost:8125
-      #
-      # Example:
-      #   subscriber = SemanticLogger::Metrics::Statsd.new(url: 'udp://localhost:8125')
-      #   SemanticLogger.on_metric(subscriber)
       def initialize(options = {})
         options = options.dup
         @url    = options.delete(:url) || 'udp://localhost:8125'

data/lib/semantic_logger/semantic_logger.rb

@@ -463,11 +463,13 @@ module SemanticLogger
   end
 
   def self.constantize_symbol(symbol, namespace = 'SemanticLogger::Appender')
-    symbol = symbol.to_s
-    klass  = symbol.respond_to?(:camelize) ? symbol.camelize : camelize(symbol)
-    klass  = "#{namespace}::#{klass}"
+    klass = "#{namespace}::#{camelize(symbol.to_s)}"
     begin
-      symbol.respond_to?(:constantize) ? klass.constantize : eval(klass)
+      if RUBY_VERSION.to_i >= 2
+        Object.const_get(klass)
+      else
+        klass.split('::').inject(Object) { |o, name| o.const_get(name) }
+      end
     rescue NameError
       raise(ArgumentError, "Could not convert symbol: #{symbol} to a class in: #{namespace}. Looking for: #{klass}")
     end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = '3.3.0'
+  VERSION = '3.4.0'
 end

data/test/appender/sentry_test.rb

@@ -0,0 +1,46 @@
+require_relative '../test_helper'
+
+# Unit Test for SemanticLogger::Appender::Bugsnag
+module Appender
+  class SentryTest < Minitest::Test
+    describe SemanticLogger::Appender::Sentry do
+      before do
+        @appender = SemanticLogger::Appender::Sentry.new(:trace)
+        @message  = 'AppenderRavenTest log message'
+        SemanticLogger.backtrace_level = :error
+      end
+
+      SemanticLogger::LEVELS.each do |level|
+        it "sends #{level} message" do
+          error_message = hash = nil
+          Raven.stub(:capture_message, -> msg, h { error_message = msg; hash = h }) do
+            @appender.send(level, @message)
+          end
+          assert_equal @message, hash[:error_message]
+          assert_equal 'SemanticLogger::Appender::Sentry', hash[:error_class]
+
+          if [:error, :fatal].include?(level)
+            assert hash.has_key?(:backtrace)
+          else
+            refute hash.has_key?(:backtrace)
+          end
+          assert_equal true, hash.has_key?(:extra)
+          assert_equal level, hash[:extra][:level]
+        end
+
+        it "sends #{level} exceptions" do
+          error     = RuntimeError.new('Oh no, Error.')
+          exception = hash = nil
+          Raven.stub(:capture_exception, -> exc, h { exception = exc; hash = h }) do
+            @appender.send(level, @message, error)
+          end
+
+          assert_equal error.class.to_s, exception.class.to_s
+          assert_equal error.message, exception.message
+          assert_equal @message, hash[:message], hash
+        end
+      end
+
+    end
+  end
+end

data/test/concerns/compatibility_test.rb

@@ -48,6 +48,14 @@ class CompatibilityTest < Minitest::Test
       refute @logger.unknown?
     end
 
+    it '#silence_logger' do
+      @logger.silence_logger do
+        @logger.info 'hello world'
+      end
+      SemanticLogger.flush
+      refute @mock_logger.message
+    end
+
     it '#<< as info' do
       @logger << 'hello world'
       SemanticLogger.flush

data/test/debug_as_trace_logger_test.rb

@@ -65,28 +65,28 @@ class DebugAsTraceLoggerTest < Minitest::Test
 
         it 'not log trace when level is debug' do
           @logger.level = :debug
-          @logger.trace('hello world', @hash) { "Calculations" }
+          @logger.trace('hello world', @hash) { 'Calculations' }
           SemanticLogger.flush
           assert_nil @mock_logger.message
         end
 
         it 'not log debug when level is debug' do
           @logger.level = :debug
-          @logger.debug('hello world', @hash) { "Calculations" }
+          @logger.debug('hello world', @hash) { 'Calculations' }
           SemanticLogger.flush
           assert_nil @mock_logger.message
         end
 
         it 'map trace to debug' do
           @logger.level = :trace
-          @logger.debug('hello world', @hash) { "Calculations" }
+          @logger.debug('hello world', @hash) { 'Calculations' }
           SemanticLogger.flush
           assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] DebugAsTraceLoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
         end
 
         it 'log trace as trace' do
           @logger.level = :trace
-          @logger.trace('hello world', @hash) { "Calculations" }
+          @logger.trace('hello world', @hash) { 'Calculations' }
           SemanticLogger.flush
           assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] DebugAsTraceLoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
         end

data/test/logger_test.rb

@@ -177,7 +177,7 @@ class LoggerTest < Minitest::Test
 
             it 'logs with backtrace and exception' do
               SemanticLogger.stub(:backtrace_level_index, 0) do
-                exc = RuntimeError.new("Test")
+                exc = RuntimeError.new('Test')
                 @logger.send(level, 'hello world', exc)
                 SemanticLogger.flush
                 assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] LoggerTest -- hello world -- Exception: RuntimeError: Test/, @mock_logger.message)
@@ -286,7 +286,7 @@ class LoggerTest < Minitest::Test
 
         describe '#with_payload' do
           it 'logs tagged payload' do
-            hash     = {tracking_number: "123456", even: 2, more: "data"}
+            hash     = {tracking_number: '123456', even: 2, more: 'data'}
             hash_str = hash.inspect.sub("{", "\\{").sub("}", "\\}")
             @logger.with_payload(tracking_number: '123456') do
               @logger.with_payload(even: 2, more: 'data') do
@@ -354,7 +354,7 @@ class LoggerTest < Minitest::Test
 
               it "log #{level} info with an exception" do
                 assert_raises RuntimeError do
-                  @logger.send("measure_#{level}", 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
+                  @logger.send("measure_#{level}", 'hello world', payload: @hash) { raise RuntimeError.new('Test') } # Measure duration of the supplied block
                 end
                 SemanticLogger.flush
                 assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message)
@@ -362,7 +362,7 @@ class LoggerTest < Minitest::Test
 
               it "change log #{level} info with an exception" do
                 assert_raises RuntimeError do
-                  @logger.send("measure_#{level}", 'hello world', payload: @hash, on_exception_level: :fatal) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
+                  @logger.send("measure_#{level}", 'hello world', payload: @hash, on_exception_level: :fatal) { raise RuntimeError.new('Test') } # Measure duration of the supplied block
                 end
                 SemanticLogger.flush
                 assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-13 00:00:00.000000000 Z
+date: 2016-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -45,6 +45,7 @@ files:
 - lib/semantic_logger/appender/http.rb
 - lib/semantic_logger/appender/mongodb.rb
 - lib/semantic_logger/appender/new_relic.rb
+- lib/semantic_logger/appender/sentry.rb
 - lib/semantic_logger/appender/splunk.rb
 - lib/semantic_logger/appender/splunk_http.rb
 - lib/semantic_logger/appender/syslog.rb
@@ -67,7 +68,6 @@ files:
 - lib/semantic_logger/logger.rb
 - lib/semantic_logger/metrics/new_relic.rb
 - lib/semantic_logger/metrics/statsd.rb
-- lib/semantic_logger/metrics/udp.rb
 - lib/semantic_logger/semantic_logger.rb
 - lib/semantic_logger/subscriber.rb
 - lib/semantic_logger/version.rb
@@ -80,6 +80,7 @@ files:
 - test/appender/mongodb_test.rb
 - test/appender/new_relic_test.rb
 - test/appender/newrelic_rpm.rb
+- test/appender/sentry_test.rb
 - test/appender/splunk_http_test.rb
 - test/appender/splunk_test.rb
 - test/appender/syslog_test.rb
@@ -112,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Scalable, next generation enterprise logging for Ruby
@@ -126,6 +127,7 @@ test_files:
 - test/appender/mongodb_test.rb
 - test/appender/new_relic_test.rb
 - test/appender/newrelic_rpm.rb
+- test/appender/sentry_test.rb
 - test/appender/splunk_http_test.rb
 - test/appender/splunk_test.rb
 - test/appender/syslog_test.rb

data/lib/semantic_logger/metrics/udp.rb

@@ -1,80 +0,0 @@
-require 'socket'
-module SemanticLogger
-  module Metrics
-    class Udp < Subscriber
-      attr_accessor :server, :separator, :udp_flags
-      attr_reader :socket
-
-      # Write metrics to in JSON format to Udp
-      #
-      # Parameters:
-      #   server: [String]
-      #     Host name and port to write UDP messages to
-      #     Example:
-      #       localhost:8125
-      #
-      #   udp_flags: [Integer]
-      #     Should be a bitwise OR of Socket::MSG_* constants.
-      #     Default: 0
-      #
-      # Limitations:
-      # * UDP packet size is limited by the connected network and any routers etc
-      #   that the message has to traverse. See https://en.wikipedia.org/wiki/Maximum_transmission_unit
-      #
-      # Example:
-      #   subscriber = SemanticLogger::Metrics::Udp.new(server: 'localhost:8125')
-      #   SemanticLogger.on_metric(subscriber)
-      def initialize(options = {}, &block)
-        options    = options.dup
-        @server    = options.delete(:server)
-        @udp_flags = options.delete(:udp_flags) || 0
-        raise(ArgumentError, 'Missing mandatory argument: :server') unless @server
-
-        super(options, &block)
-        reopen
-      end
-
-      # After forking an active process call #reopen to re-open
-      # open the handles to resources
-      def reopen
-        close
-        @socket    = UDPSocket.new
-        host, port = server.split(':')
-        @socket.connect(host, port)
-      end
-
-      def call(log)
-        metric = log.metric
-        if duration = log.duration
-          @statsd.timing(metric, duration)
-        else
-          amount = (log.metric_amount || 1).round
-          if amount < 0
-            amount.times { @statsd.decrement(metric) }
-          else
-            amount.times { @statsd.increment(metric) }
-          end
-        end
-        @socket.send(data, udp_flags)
-      end
-
-      # Flush is called by the semantic_logger during shutdown.
-      def flush
-        @socket.flush if @socket
-      end
-
-      # Close is called during shutdown, or with reopen
-      def close
-        @socket.close if @socket
-      end
-
-      private
-
-      # Returns [SemanticLogger::Formatters::Default] formatter default for this Appender
-      def default_formatter
-        SemanticLogger::Formatters::Json.new
-      end
-
-    end
-  end
-end