semantic_logger 3.2.1 → 3.3.0

data/lib/semantic_logger/metrics/udp.rb

@@ -0,0 +1,80 @@
+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

data/lib/semantic_logger/semantic_logger.rb

@@ -63,7 +63,7 @@ module SemanticLogger
   # Returns [String] name of this application for logging purposes
   # Note: Not all appenders use `application`
   def self.application
-    @@application ||= 'Semantic Logger'
+    @@application
   end
 
   # Override the default application
@@ -71,6 +71,8 @@ module SemanticLogger
     @@application = application
   end
 
+  @@application = 'Semantic Logger'
+
   # Add a new logging appender as a new destination for all log messages
   # emitted from Semantic Logger
   #
@@ -90,12 +92,12 @@ module SemanticLogger
   #     For example STDOUT, STDERR, etc.
   #
   #   Or,
-  #   appender: [Symbol|SemanticLogger::Appender::Base]
+  #   appender: [Symbol|SemanticLogger::Subscriber]
   #     A symbol identifying the appender to create.
   #     For example:
   #       :bugsnag, :elasticsearch, :graylog, :http, :mongodb, :new_relic, :splunk_http, :syslog, :wrapper
   #          Or,
-  #     An instance of an appender derived from SemanticLogger::Appender::Base
+  #     An instance of an appender derived from SemanticLogger::Subscriber
   #     For example:
   #       SemanticLogger::Appender::Http.new(url: 'http://localhost:8088/path')
   #
@@ -165,7 +167,7 @@ module SemanticLogger
     @@appenders.delete(appender)
   end
 
-  # Returns [SemanticLogger::Appender::Base] a copy of the list of active
+  # Returns [SemanticLogger::Subscriber] a copy of the list of active
   # appenders for debugging etc.
   # Use SemanticLogger.add_appender and SemanticLogger.remove_appender
   # to manipulate the active appenders list
@@ -179,6 +181,11 @@ module SemanticLogger
     SemanticLogger::Logger.flush
   end
 
+  # Close and flush all appenders
+  def self.close
+    SemanticLogger::Logger.close
+  end
+
   # After forking an active process call SemanticLogger.reopen to re-open
   # any open file handles etc to resources
   #
@@ -429,51 +436,40 @@ module SemanticLogger
       options[:file_name] = appender
     elsif appender.is_a?(IO)
       options[:io] = appender
-    elsif appender.is_a?(Symbol) || appender.is_a?(Appender::Base)
+    elsif appender.is_a?(Symbol) || appender.is_a?(Subscriber)
       options[:appender] = appender
     else
       options[:logger] = appender
     end
-    warn "[DEPRECATED] SemanticLogger.add_appender parameters have changed. Please use: #{options.inspect}"
+    warn "[DEPRECATED] SemanticLogger.add_appender parameters have changed. Please use: #{options.inspect}" if $VERBOSE
     options
   end
 
-  # Returns [SemanticLogger::Appender::Base] appender for the supplied options
+  # Returns [SemanticLogger::Subscriber] appender for the supplied options
   def self.appender_from_options(options, &block)
     if options[:io] || options[:file_name]
       SemanticLogger::Appender::File.new(options, &block)
     elsif appender = options.delete(:appender)
       if appender.is_a?(Symbol)
-        named_appender(appender).new(options)
-      elsif appender.is_a?(Appender::Base)
+        constantize_symbol(appender).new(options)
+      elsif appender.is_a?(Subscriber)
         appender
       else
-        raise(ArgumentError, "Parameter :appender must be either a Symbol or an object derived from SemanticLogger::Appender::Base, not: #{appender.inspect}")
+        raise(ArgumentError, "Parameter :appender must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
       end
     elsif options[:logger]
       SemanticLogger::Appender::Wrapper.new(options, &block)
     end
   end
 
-  def self.named_appender(appender, root = 'SemanticLogger::Appender')
-    appender = appender.to_s
-    klass    = appender.respond_to?(:camelize) ? appender.camelize : camelize(appender)
-    klass    = "#{root}::#{klass}"
+  def self.constantize_symbol(symbol, namespace = 'SemanticLogger::Appender')
+    symbol = symbol.to_s
+    klass  = symbol.respond_to?(:camelize) ? symbol.camelize : camelize(symbol)
+    klass  = "#{namespace}::#{klass}"
     begin
-      appender.respond_to?(:constantize) ? klass.constantize : eval(klass)
+      symbol.respond_to?(:constantize) ? klass.constantize : eval(klass)
     rescue NameError
-      raise(ArgumentError, "Could not find #{root} class: #{klass} for #{appender}")
-    end
-  end
-
-  def self.named_formatter(formatter)
-    formatter = formatter.to_s
-    klass     = formatter.respond_to?(:camelize) ? formatter.camelize : camelize(formatter)
-    klass     = "SemanticLogger::Formatters::#{klass}"
-    begin
-      formatter.respond_to?(:constantize) ? klass.constantize : eval(klass)
-    rescue NameError => exc
-      raise(ArgumentError, "Could not find formatter class: #{klass} for #{appender}")
+      raise(ArgumentError, "Could not convert symbol: #{symbol} to a class in: #{namespace}. Looking for: #{klass}")
     end
   end
 

data/lib/semantic_logger/subscriber.rb

@@ -0,0 +1,127 @@
+# Abstract Subscriber
+#
+#   Abstract base class for appender and metrics subscribers.
+module SemanticLogger
+  class Subscriber < SemanticLogger::Base
+    # Every logger has its own formatter
+    attr_accessor :formatter
+    attr_writer :application, :host
+
+    # Returns the current log level if set, otherwise it logs everything it receives
+    def level
+      @level || :trace
+    end
+
+    # A subscriber should implement flush if it can.
+    def flush
+      # NOOP
+    end
+
+    # A subscriber should implement close if it can.
+    def close
+      # NOOP
+    end
+
+    # Returns [SemanticLogger::Formatters::Default] formatter default for this subscriber
+    def default_formatter
+      SemanticLogger::Formatters::Default.new
+    end
+
+    # Allow application name to be set globally or per subscriber
+    def application
+      @application || SemanticLogger.application
+    end
+
+    # Allow host name to be set globally or per subscriber
+    def host
+      @host || SemanticLogger.host
+    end
+
+    private
+
+    # Initializer for Abstract Class SemanticLogger::Subscriber
+    #
+    # Parameters
+    #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+    #     Override the log level for this subscriber.
+    #     Default: :error
+    #
+    #   formatter: [Object|Proc]
+    #     An instance of a class that implements #call, or a Proc to be used to format
+    #     the output from this subscriber
+    #     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)
+      # Backward compatibility
+      options      = {level: options} unless options.is_a?(Hash)
+      options      = options.dup
+      level        = options.delete(:level)
+      filter       = options.delete(:filter)
+      @formatter   = extract_formatter(options.delete(:formatter), &block)
+      @application = options.delete(:application)
+      @host        = options.delete(:host)
+      raise(ArgumentError, "Unknown options: #{options.inspect}") if options.size > 0
+
+      # Subscribers don't take a class name, so use this class name if an subscriber
+      # is logged to directly
+      super(self.class, level, filter)
+    end
+
+    # Return the level index for fast comparisons
+    # Returns the lowest level index if the level has not been explicitly
+    # set for this instance
+    def level_index
+      @level_index || 0
+    end
+
+    # Return formatter that responds to call
+    # Supports formatter supplied as:
+    # - Symbol
+    # - Hash ( Symbol => { options })
+    # - Instance of any of SemanticLogger::Formatters
+    # - Proc
+    # - Any object that responds to :call
+    # - If none of the above apply, then the supplied block is returned as the formatter.
+    # - Otherwise an instance of the default formatter is returned.
+    def extract_formatter(formatter, &block)
+      case
+      when formatter.is_a?(Symbol)
+        SemanticLogger.constantize_symbol(formatter, 'SemanticLogger::Formatters').new
+      when formatter.is_a?(Hash) && formatter.size > 0
+        fmt, options = formatter.first
+        SemanticLogger.constantize_symbol(fmt.to_sym, 'SemanticLogger::Formatters').new(options)
+      when formatter.respond_to?(:call)
+        formatter
+      when block
+        block
+      when respond_to?(:call)
+        self
+      else
+        default_formatter
+      end
+    end
+
+    SUBSCRIBER_OPTIONS = [:level, :formatter, :filter, :application, :host].freeze
+
+    # Returns [Hash] the subscriber common options from the supplied Hash
+    def extract_subscriber_options!(options)
+      subscriber_options = {}
+      SUBSCRIBER_OPTIONS.each { |key| subscriber_options[key] = options.delete(key) if options.has_key?(key) }
+      subscriber_options
+    end
+
+  end
+end

data/lib/semantic_logger/version.rb

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

data/test/appender/elasticsearch_test.rb

@@ -7,10 +7,12 @@ module Appender
 
     describe SemanticLogger::Appender::Elasticsearch do
       before do
-        @appender = SemanticLogger::Appender::Elasticsearch.new(
-          url: 'http://localhost:9200'
-        )
-        @message  = 'AppenderElasticsearchTest log message'
+        Net::HTTP.stub_any_instance(:start, true) do
+          @appender = SemanticLogger::Appender::Elasticsearch.new(
+            url: 'http://localhost:9200'
+          )
+        end
+        @message = 'AppenderElasticsearchTest log message'
       end
 
       it 'logs to daily indexes' do

data/test/appender/file_test.rb

@@ -20,48 +20,48 @@ module Appender
       describe 'format logs into text form' do
         it 'handle no message or payload' do
           @appender.debug
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File\n/, @io.string
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File\n/, @io.string)
         end
 
         it 'handle message' do
           @appender.debug 'hello world'
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world\n/, @io.string
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world\n/, @io.string)
         end
 
         it 'handle message and payload' do
           @appender.debug 'hello world', @hash
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string)
         end
 
         it 'handle message, payload, and exception' do
           @appender.debug 'hello world', @hash, StandardError.new('StandardError')
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str} -- Exception: StandardError: StandardError\n\n/, @io.string
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str} -- Exception: StandardError: StandardError\n\n/, @io.string)
         end
 
         it 'logs exception with nil backtrace' do
           @appender.debug StandardError.new('StandardError')
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- Exception: StandardError: StandardError\n\n/, @io.string
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- Exception: StandardError: StandardError\n\n/, @io.string)
         end
 
         it 'handle nested exception' do
           begin
             raise StandardError, 'FirstError'
-          rescue Exception => e
+          rescue Exception
             begin
               raise StandardError, 'SecondError'
             rescue Exception => e2
               @appender.debug e2
             end
           end
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name} file_test.rb:\d+\] SemanticLogger::Appender::File -- Exception: StandardError: SecondError\n/, @io.string
-          assert_match /^Cause: StandardError: FirstError\n/, @io.string if Exception.instance_methods.include?(:cause)
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name} file_test.rb:\d+\] SemanticLogger::Appender::File -- Exception: StandardError: SecondError\n/, @io.string)
+          assert_match(/^Cause: StandardError: FirstError\n/, @io.string) if Exception.instance_methods.include?(:cause)
         end
 
         it 'logs exception with empty backtrace' do
           exc = StandardError.new('StandardError')
           exc.set_backtrace([])
           @appender.debug exc
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- Exception: StandardError: StandardError\n\n/, @io.string
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- Exception: StandardError: StandardError\n\n/, @io.string)
         end
       end
 
@@ -71,14 +71,14 @@ module Appender
           it "log #{level} with file_name" do
             SemanticLogger.stub(:backtrace_level_index, 0) do
               @appender.send(level, 'hello world', @hash)
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}#{@file_name_reg_exp}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string
+              assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}#{@file_name_reg_exp}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string)
             end
           end
 
           it "log #{level} without file_name" do
             SemanticLogger.stub(:backtrace_level_index, 100) do
               @appender.send(level, 'hello world', @hash)
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string
+              assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string)
             end
           end
         end
@@ -101,7 +101,7 @@ module Appender
 
         it 'format using formatter' do
           @appender.debug
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ DEBUG \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- \n/, @io.string
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ DEBUG \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- \n/, @io.string)
         end
       end
 

data/test/appender/honeybadger_test.rb

@@ -7,6 +7,7 @@ module Appender
       before do
         @appender = SemanticLogger::Appender::Honeybadger.new(:trace)
         @message  = 'AppenderHoneybadgerTest log message'
+        SemanticLogger.backtrace_level = :error
       end
 
       SemanticLogger::LEVELS.each do |level|
@@ -17,7 +18,12 @@ module Appender
           end
           assert_equal @message, hash[:error_message]
           assert_equal 'SemanticLogger::Appender::Honeybadger', hash[:error_class]
-          assert_equal true, hash.has_key?(:backtrace)
+
+          if [:error, :fatal].include?(level)
+            assert hash.has_key?(:backtrace)
+          else
+            refute hash.has_key?(:backtrace)
+          end
           assert_equal true, hash.has_key?(:context)
           assert_equal level, hash[:context][:level]
         end