semantic_logger 4.5.0 → 4.6.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34b3b78799e196b270d81aba7deb9b0accd1187a900967a3943dd03301c63199
-  data.tar.gz: 775b6eeca4ca6b9c38e9213e7f32fee9d179ce36148433dfa91a8630f74873b3
+  metadata.gz: bafa2ce169caccee2a851d7ad8a5b5b7d1e3104fa6894ff8c21756e78f59621f
+  data.tar.gz: 110b972e305d619672761cbc34652556615d79015824c1c538c8819e69a01ec8
 SHA512:
-  metadata.gz: 7cda8a50c62a2dcdb079d5f96cbde61e5cc941c443122a3bbc102a1513bc3686d44a20cca28e7627444bf640a6329035aefc43cb6111a3e6b9cb91411fe33782
-  data.tar.gz: caf355bf16e08b133fe07ddd6b4cab813b6e7224b3e1f152e1ab54cf30f574fc8665f99ae3938078fb35fcfeea3643d565a814cbe2774d263135c93722147b06
+  metadata.gz: bec35476ebcc1af48f5b056b7f109652d86c437da257e70e82a2514dfdbf280d12cc7acd29c9c09a49ed76fbd7d7b09ac200a9d3477089685e4e2a45b9d899fe
+  data.tar.gz: 501e8708e49344fb056e9959c8d77b2a907fbbfe938893a5000edbb1dd9f57d710abd341e5b0566f7aafdb624ea424a38815de89fa845fcdaf01563aa41c0d72

data/lib/semantic_logger/ansi_colors.rb

@@ -11,15 +11,5 @@ module SemanticLogger
     MAGENTA = "\e[35m".freeze
     CYAN    = "\e[36m".freeze
     WHITE   = "\e[37m".freeze
-
-    # DEPRECATED - NOT USED
-    LEVEL_MAP = {
-      trace: MAGENTA,
-      debug: GREEN,
-      info:  CYAN,
-      warn:  BOLD,
-      error: RED,
-      fatal: RED
-    }.freeze
   end
 end

data/lib/semantic_logger/appender.rb

@@ -23,71 +23,62 @@ module SemanticLogger
     autoload :Wrapper,           'semantic_logger/appender/wrapper'
     # @formatter:on
 
-    # DEPRECATED, use SemanticLogger::AnsiColors
-    AnsiColors = SemanticLogger::AnsiColors
-
-    # DEPRECATED: use SemanticLogger::Formatters::Color.new
-    def self.colorized_formatter
-      SemanticLogger::Formatters::Color.new
-    end
-
-    # DEPRECATED: use SemanticLogger::Formatters::Json.new
-    def self.json_formatter
-      SemanticLogger::Formatters::Json.new
-    end
-
     # Returns [SemanticLogger::Subscriber] appender for the supplied options
-    def self.factory(options, &block)
-      options = options.dup
-      async   = options.delete(:async)
-      batch   = options.delete(:batch)
-
-      # Extract batch and async options
-      proxy_options = {}
-      ASYNC_OPTION_KEYS.each { |key| proxy_options[key] = options.delete(key) if options.key?(key) }
-
-      appender = build(options, &block)
+    def self.factory(async: false, batch: nil,
+      max_queue_size: 10_000, lag_check_interval: 1_000, lag_threshold_s: 30,
+      batch_size: 300, batch_seconds: 5,
+      **args,
+      &block
+    )
+      appender = build(**args, &block)
 
       # If appender implements #batch, then it should use the batch proxy by default.
       batch    = true if batch.nil? && appender.respond_to?(:batch)
 
       if batch == true
-        proxy_options[:appender] = appender
-        Appender::AsyncBatch.new(proxy_options)
+        Appender::AsyncBatch.new(
+          appender:           appender,
+          max_queue_size:     max_queue_size,
+          lag_threshold_s:    lag_threshold_s,
+          batch_size:         batch_size,
+          batch_seconds:      batch_seconds
+        )
       elsif async == true
-        proxy_options[:appender] = appender
-        Appender::Async.new(proxy_options)
-
-
+        Appender::Async.new(
+          appender:           appender,
+          max_queue_size:     max_queue_size,
+          lag_check_interval: lag_check_interval,
+          lag_threshold_s:    lag_threshold_s
+        )
       else
         appender
       end
     end
 
-    ASYNC_OPTION_KEYS = %i[max_queue_size lag_threshold_s batch_size batch_seconds lag_check_interval].freeze
-
     # Returns [Subscriber] instance from the supplied options.
-    def self.build(options, &block)
-      if options[:io] || options[:file_name]
-        SemanticLogger::Appender::File.new(options, &block)
-      elsif (appender = options.delete(:appender))
+    def self.build(io: nil, file_name: nil, appender: nil, metric: nil, logger: nil, **args, &block)
+      if io || file_name
+        SemanticLogger::Appender::File.new(io: io, file_name: file_name, **args, &block)
+      elsif logger
+        SemanticLogger::Appender::Wrapper.new(logger: logger, **args, &block)
+      elsif appender
         if appender.is_a?(Symbol)
-          SemanticLogger::Utils.constantize_symbol(appender).new(options)
+          SemanticLogger::Utils.constantize_symbol(appender).new(**args)
         elsif appender.is_a?(Subscriber)
           appender
         else
           raise(ArgumentError, "Parameter :appender must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
         end
-      elsif (appender = options.delete(:metric))
-        if appender.is_a?(Symbol)
-          SemanticLogger::Utils.constantize_symbol(appender, 'SemanticLogger::Metric').new(options)
-        elsif appender.is_a?(Subscriber)
-          appender
+      elsif metric
+        if metric.is_a?(Symbol)
+          SemanticLogger::Utils.constantize_symbol(metric, 'SemanticLogger::Metric').new(**args)
+        elsif metric.is_a?(Subscriber)
+          metric
         else
           raise(ArgumentError, "Parameter :metric 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)
+      else
+        raise(ArgumentError, 'To create an appender it must supply one of the following: :io, :file_name, :appender, :metric, or :logger')
       end
     end
 

data/lib/semantic_logger/appender/async.rb

@@ -15,6 +15,7 @@ module SemanticLogger
       def_delegator :@appender, :filter
       def_delegator :@appender, :host
       def_delegator :@appender, :application
+      def_delegator :@appender, :environment
       def_delegator :@appender, :level
       def_delegator :@appender, :level=
       def_delegator :@appender, :logger

data/lib/semantic_logger/appender/elasticsearch.rb

@@ -131,6 +131,7 @@ module SemanticLogger
                      formatter: nil,
                      filter: nil,
                      application: nil,
+                     environment: nil,
                      host: nil,
                      metrics: false,
                      **elasticsearch_args,
@@ -144,7 +145,7 @@ module SemanticLogger
         @elasticsearch_args[:url]    = url if url && !elasticsearch_args[:hosts]
         @elasticsearch_args[:logger] = logger
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, metrics: false, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: false, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/splunk.rb

@@ -127,6 +127,7 @@ module SemanticLogger
           message: h.delete(:message),
           event:   h
         }
+        message[:environment] = logger.environment if logger.environment
         message[:sourcetype] = source_type if source_type
         message
       end

data/lib/semantic_logger/appender/splunk_http.rb

@@ -96,6 +96,7 @@ module SemanticLogger
           time:   h.delete(:time),
           event:  h
         }
+        message[:environment] = logger.environment if logger.environment
         message[:sourcetype]  = source_type if source_type
         message[:index]       = index if index
         message.to_json

data/lib/semantic_logger/appender/tcp.rb

@@ -89,7 +89,7 @@ module SemanticLogger
       #     where multiple sends are expected during a single response
       #     Default: true
       #
-      #   :connect_retry_count [Fixnum]
+      #   :connect_retry_count [Integer]
       #     Number of times to retry connecting when a connection fails
       #     Default: 10
       #
@@ -97,7 +97,7 @@ module SemanticLogger
       #     Number of seconds between connection retry attempts after the first failed attempt
       #     Default: 0.5
       #
-      #   :retry_count [Fixnum]
+      #   :retry_count [Integer]
       #     Number of times to retry when calling #retry_on_connection_failure
       #     This is independent of :connect_retry_count which still applies with
       #     connection failures. This retry controls upto how many times to retry the
@@ -182,7 +182,7 @@ module SemanticLogger
       #     connect_retry_count:    5
       #   )
       def initialize(separator: "\n",
-                     level: nil, formatter: nil, filter: nil, application: nil, host: nil, metrics: false,
+                     level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil, metrics: false,
                      **tcp_client_args, &block)
         @separator       = separator
         @tcp_client_args = tcp_client_args
@@ -191,7 +191,7 @@ module SemanticLogger
         Net::TCPClient.logger      = logger
         Net::TCPClient.logger.name = 'Net::TCPClient'
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, &block)
         reopen
       end
 

data/lib/semantic_logger/appenders.rb

@@ -8,9 +8,8 @@ module SemanticLogger
       @logger.name = self.class.name
     end
 
-    def add(options, deprecated_level = nil, &block)
-      options  = options.is_a?(Hash) ? options.dup : convert_old_appender_args(options, deprecated_level)
-      appender = SemanticLogger::Appender.factory(options, &block)
+    def add(**args, &block)
+      appender = SemanticLogger::Appender.factory(**args, &block)
       self << appender
       appender
     end
@@ -65,25 +64,5 @@ module SemanticLogger
       end
       logger.trace 'All appenders re-opened'
     end
-
-    private
-
-    # Backward compatibility
-    def convert_old_appender_args(appender, level)
-      options         = {}
-      options[:level] = level if level
-
-      if appender.is_a?(String)
-        options[:file_name] = appender
-      elsif appender.is_a?(IO)
-        options[:io] = appender
-      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}"
-      options
-    end
   end
 end

data/lib/semantic_logger/base.rb

@@ -233,23 +233,11 @@ module SemanticLogger
       SemanticLogger.silence(new_level, &block)
     end
 
-    # Deprecated. Use `SemanticLogger.tagged`
+    # :nodoc:
     def fast_tag(tag, &block)
       SemanticLogger.fast_tag(tag, &block)
     end
 
-    # :nodoc:
-    def with_payload(payload, &block)
-      warn '#with_payload is deprecated, use SemanticLogger.named_tagged'
-      SemanticLogger.named_tagged(payload, &block)
-    end
-
-    # :nodoc:
-    def payload
-      warn '#payload is deprecated, use SemanticLogger.named_tags'
-      SemanticLogger.named_tags
-    end
-
     # Write log data to underlying data storage
     def log(_log_)
       raise NotImplementedError, 'Logging Appender must implement #log(log)'

data/lib/semantic_logger/formatters/base.rb

@@ -2,11 +2,11 @@ require 'time'
 module SemanticLogger
   module Formatters
     class Base
-      attr_accessor :time_format, :log_host, :log_application, :precision
+      attr_accessor :time_format, :log_host, :log_application, :log_environment, :precision
 
       # Time precision varies by Ruby interpreter
       # JRuby 9.1.8.0 supports microseconds
-      PRECISION   =
+      PRECISION =
         if defined?(JRuby)
           if JRUBY_VERSION.to_f >= 9.1
             maint = JRUBY_VERSION.match(/\A\d+\.\d+\.(\d+)\./)[1].to_i
@@ -34,11 +34,15 @@ module SemanticLogger
       #   precision: [Integer]
       #     How many fractional digits to log times with.
       #     Default: PRECISION (6, except on older JRuby, where 3)
-      def initialize(time_format: nil, log_host: true, log_application: true,
+      def initialize(time_format: nil,
+                     log_host: true,
+                     log_application: true,
+                     log_environment: true,
                      precision: PRECISION)
         @time_format     = time_format || self.class.build_time_format(precision)
         @log_host        = log_host
         @log_application = log_application
+        @log_environment = log_environment
         @precision       = precision
       end
 
@@ -48,7 +52,7 @@ module SemanticLogger
       #   precision: [Integer]
       #     How many fractional digits to log times with.
       #     Default: PRECISION (6, except on older JRuby, where 3)
-      def self.build_time_format(precision=PRECISION)
+      def self.build_time_format(precision = PRECISION)
         "%Y-%m-%d %H:%M:%S.%#{precision}N"
       end
 

data/lib/semantic_logger/formatters/color.rb

@@ -70,15 +70,10 @@ module SemanticLogger
       #
       #  color_map: [Hash | SemanticLogger::Formatters::Color::ColorMap]
       #    ColorMaps each of the log levels to a color
-      def initialize(ap: {multiline: false},
-                     color_map: ColorMap.new,
-                     time_format: nil,
-                     log_host: false,
-                     log_application: false,
-                     precision: PRECISION)
+      def initialize(ap: {multiline: false}, color_map: ColorMap.new, **args)
         @ai_options = ap
         @color_map  = color_map.is_a?(ColorMap) ? color_map : ColorMap.new(color_map)
-        super(time_format: time_format, log_host: log_host, log_application: log_application, precision: precision)
+        super(**args)
       end
 
       def level

data/lib/semantic_logger/formatters/fluentd.rb

@@ -2,18 +2,18 @@ require 'json'
 
 module SemanticLogger
   module Formatters
-    # Fluentd is similar to SemanticLogger::Formatters::Json but with log level that are recongnized
+    # Fluentd is similar to SemanticLogger::Formatters::Json but with log levels that are recognized
     # by kubernetes fluentd.
     class Fluentd < Json
       attr_reader :need_process_info
 
-      def initialize(log_host: true, log_application: true, need_process_info: false)
+      def initialize(time_format: :rfc_3339, time_key: :time, need_process_info: false, **args)
         @need_process_info = need_process_info
-        super(log_host: log_host, log_application: log_application, time_key: 'time', time_format: :rfc_3339)
+        super(time_format: time_format, time_key: time_key, **args)
       end
 
-      def severity
-        hash['severity'] = log.level
+      def level
+        hash['severity']       = log.level
         hash['severity_index'] = log.level_index
       end
 
@@ -21,17 +21,6 @@ module SemanticLogger
         # Ignore fields: pid, thread, file and line by default
         super() if need_process_info
       end
-
-      def call(log, logger)
-        self.hash   = {}
-        self.log    = log
-        self.logger = logger
-
-        host; application; time; severity; process_info; duration; tags; named_tags; name; message; payload; exception; metric
-        hash
-
-        hash.to_json
-      end
     end
   end
 end

data/lib/semantic_logger/formatters/json.rb

@@ -3,10 +3,8 @@ module SemanticLogger
   module Formatters
     class Json < Raw
       # Default JSON time format is ISO8601
-      def initialize(time_format: :iso_8601, log_host: true, log_application: true, time_key: :timestamp,
-                     precision: PRECISION)
-        super(time_format: time_format, log_host: log_host, log_application: log_application, time_key: time_key,
-              precision: precision)
+      def initialize(time_format: :iso_8601, time_key: :timestamp, **args)
+        super(time_format: time_format, time_key: time_key, **args)
       end
 
       # Returns log messages in JSON format

data/lib/semantic_logger/formatters/raw.rb

@@ -6,9 +6,9 @@ module SemanticLogger
       attr_accessor :hash, :log, :logger, :time_key
 
       # By default Raw formatter does not reformat the time
-      def initialize(time_format: :none, log_host: true, log_application: true, time_key: :time, precision: PRECISION)
+      def initialize(time_format: :none, time_key: :time, **args)
         @time_key = time_key
-        super(time_format: time_format, log_host: log_host, log_application: log_application, precision: precision)
+        super(time_format: time_format, **args)
       end
 
       # Host name
@@ -18,7 +18,12 @@ module SemanticLogger
 
       # Application name
       def application
-        hash[:application] = logger.application if log_application && logger.application
+        hash[:application] = logger.application if log_application && logger && logger.application
+      end
+
+      # Environment
+      def environment
+        hash[:environment] = logger.environment if log_environment && logger && logger.environment
       end
 
       # Date & time
@@ -104,7 +109,7 @@ module SemanticLogger
         self.log    = log
         self.logger = logger
 
-        host; application; time; level; process_info; duration; tags; named_tags; name; message; payload; exception; metric
+        host; application; environment; time; level; process_info; duration; tags; named_tags; name; message; payload; exception; metric
         hash
       end
     end

data/lib/semantic_logger/formatters/signalfx.rb

@@ -2,29 +2,21 @@ require 'json'
 module SemanticLogger
   module Formatters
     class Signalfx < Base
-      attr_accessor :token, :dimensions, :hash, :log, :logger, :gauge_name, :counter_name, :environment
+      attr_accessor :token, :dimensions, :hash, :log, :logger, :gauge_name, :counter_name
 
       def initialize(token:,
                      dimensions: nil,
-                     log_host: true,
-                     log_application: true,
                      gauge_name: 'Application.average',
                      counter_name: 'Application.counter',
-                     environment: true,
-                     precision: PRECISION)
+                     time_format: :ms,
+                     **args)
 
         @token        = token
         @dimensions   = dimensions.map(&:to_sym) if dimensions
         @gauge_name   = gauge_name
         @counter_name = counter_name
 
-        if environment == true
-          @environment = defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
-        elsif environment
-          @environment = environment
-        end
-
-        super(time_format: :ms, log_host: log_host, log_application: log_application, precision: precision)
+        super(time_format: time_format, **args)
       end
 
       # Create SignalFx friendly metric.
@@ -80,7 +72,7 @@ module SemanticLogger
         end
         h[:host]        = logger.host if log_host && logger.host
         h[:application] = logger.application if log_application && logger.application
-        h[:environment] = environment if environment
+        h[:environment] = logger.environment if log_environment && logger.environment
       end
 
       # Returns [Hash] log message in Signalfx format.

data/lib/semantic_logger/log.rb

@@ -279,22 +279,6 @@ module SemanticLogger
       !(payload.nil? || (payload.respond_to?(:empty?) && payload.empty?))
     end
 
-    # DEPRECATED
-    alias has_payload? payload?
-
-    # DEPRECATED
-    def formatted_time
-      time.strftime(Formatters::Base.build_time_format)
-    end
-
-    DeprecatedLogger = Struct.new(:host, :application)
-
-    # DEPRECATED: Use SemanticLogger::Formatters::Raw
-    def to_h(host = SemanticLogger.host, application = SemanticLogger.application)
-      logger = DeprecatedLogger.new(host, application)
-      SemanticLogger::Formatters::Raw.new.call(self, logger)
-    end
-
     # Lazy initializes the context hash and assigns a key value pair.
     def set_context(key, value)
       (self.context ||= {})[key] = value

data/lib/semantic_logger/semantic_logger.rb

@@ -71,7 +71,19 @@ module SemanticLogger
     @application = application
   end
 
-  @application = 'Semantic Logger'
+  # Returns [String] name of this environment for logging purposes
+  # Note: Not all appenders use `environment`
+  def self.environment
+    @environment
+  end
+
+  # Override the default environment
+  def self.environment=(environment)
+    @environment = environment
+  end
+
+  @application = ENV['SEMANTIC_LOGGER_APP'] || 'Semantic Logger'
+  @environment = ENV['SEMANTIC_LOGGER_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV']
 
   # Add a new logging appender as a new destination for all log messages
   # emitted from Semantic Logger
@@ -151,8 +163,8 @@ module SemanticLogger
   #   logger = SemanticLogger['Example']
   #   logger.info "Hello World"
   #   logger.debug("Login time", user: 'Joe', duration: 100, ip_address: '127.0.0.1')
-  def self.add_appender(options, deprecated_level = nil, &block)
-    appender = Logger.processor.appenders.add(options, deprecated_level, &block)
+  def self.add_appender(**args, &block)
+    appender = Logger.processor.appenders.add(**args, &block)
     # Start appender thread if it is not already running
     Logger.processor.start
     appender

data/lib/semantic_logger/subscriber.rb

@@ -5,7 +5,7 @@ module SemanticLogger
   class Subscriber < SemanticLogger::Base
     # Every appender has its own formatter
     attr_reader :formatter
-    attr_writer :application, :host, :logger, :metrics
+    attr_writer :application, :environment, :host, :logger, :metrics
 
     # Returns the current log level if set, otherwise it logs everything it receives.
     def level
@@ -32,6 +32,11 @@ module SemanticLogger
       @application || SemanticLogger.application
     end
 
+    # Allow environment name to be set globally or on a per subscriber basis.
+    def environment
+      @environment || SemanticLogger.environment
+    end
+
     # Allow host name to be set globally or on a per subscriber basis.
     def host
       @host || SemanticLogger.host
@@ -92,9 +97,10 @@ module SemanticLogger
     #   metrics: [Boolean]
     #     Whether to log metric only entries with this subscriber.
     #     Default: false
-    def initialize(level: nil, formatter: nil, filter: nil, application: nil, host: nil, metrics: false, &block)
+    def initialize(level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil, metrics: false, &block)
       self.formatter = block || formatter
       @application   = application
+      @environment   = environment
       @host          = host
       @metrics       = metrics
 

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger
-  VERSION = '4.5.0'.freeze
+  VERSION = '4.6.0.beta1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.5.0
+  version: 4.6.0.beta1
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-21 00:00:00.000000000 Z
+date: 2019-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -102,11 +102,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Feature rich logging framework, and replacement for existing Ruby & Rails