semantic_logger 4.5.0 → 4.12.0

data/lib/semantic_logger/appender/kafka.rb

@@ -1,10 +1,10 @@
 begin
-  require 'kafka'
+  require "kafka"
 rescue LoadError
-  raise 'Gem ruby-kafka is required for logging to Elasticsearch. Please add the gem "ruby-kafka" to your Gemfile.'
+  raise LoadError, 'Gem ruby-kafka is required for logging to Elasticsearch. Please add the gem "ruby-kafka" to your Gemfile.'
 end
 
-require 'date'
+require "date"
 
 # Forward all log messages to Apache Kafka.
 #
@@ -23,8 +23,8 @@ module SemanticLogger
   module Appender
     class Kafka < SemanticLogger::Subscriber
       attr_accessor :seed_brokers, :client_id, :connect_timeout, :socket_timeout,
-                    :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_key,
-                    :delivery_threshold, :delivery_interval,
+                    :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_key, :ssl_ca_certs_from_system,
+                    :delivery_threshold, :delivery_interval, :required_acks,
                     :topic, :partition, :partition_key, :key
 
       # Send log messages to Kafka in JSON format.
@@ -79,6 +79,9 @@ module SemanticLogger
       #     Must be used in combination with ssl_client_cert.
       #     Default: nil
       #
+      #   ssl_ca_certs_from_system: [boolean]
+      #     Delegate SSL CA cert to the system certs
+      #
       #    delivery_threshold: [Integer]
       #      Number of messages between triggering a delivery of messages to Apache Kafka.
       #      Default: 100
@@ -87,6 +90,10 @@ module SemanticLogger
       #      Number of seconds between triggering a delivery of messages to Apache Kafka.
       #      Default: 5
       #
+      #    required_acks: [Integer]
+      #      Number of replicas that must acknowledge receipt of each log message to the topic
+      #      Default: 1
+      #
       # Semantic Logger Parameters:
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
@@ -115,25 +122,27 @@ module SemanticLogger
       #   metrics: [Boolean]
       #     Send metrics only events to kafka.
       #     Default: true
-      def initialize(seed_brokers:, client_id: 'semantic-logger', connect_timeout: nil, socket_timeout: nil,
-                     ssl_ca_cert: nil, ssl_client_cert: nil, ssl_client_cert_key: nil,
-                     topic: 'log_messages', partition: nil, partition_key: nil, key: nil,
-                     delivery_threshold: 100, delivery_interval: 10,
+      def initialize(seed_brokers:, client_id: "semantic-logger", connect_timeout: nil, socket_timeout: nil,
+                     ssl_ca_cert: nil, ssl_client_cert: nil, ssl_client_cert_key: nil, ssl_ca_certs_from_system: false,
+                     topic: "log_messages", partition: nil, partition_key: nil, key: nil,
+                     delivery_threshold: 100, delivery_interval: 10, required_acks: 1,
                      metrics: true, **args, &block)
 
-        @seed_brokers        = seed_brokers
-        @client_id           = client_id
-        @connect_timeout     = connect_timeout
-        @socket_timeout      = socket_timeout
-        @ssl_ca_cert         = ssl_ca_cert
-        @ssl_client_cert     = ssl_client_cert
-        @ssl_client_cert_key = ssl_client_cert_key
-        @topic               = topic
-        @partition           = partition
-        @partition_key       = partition_key
-        @key                 = key
-        @delivery_threshold  = delivery_threshold
-        @delivery_interval   = delivery_interval
+        @seed_brokers             = seed_brokers
+        @client_id                = client_id
+        @connect_timeout          = connect_timeout
+        @socket_timeout           = socket_timeout
+        @ssl_ca_cert              = ssl_ca_cert
+        @ssl_client_cert          = ssl_client_cert
+        @ssl_client_cert_key      = ssl_client_cert_key
+        @ssl_ca_certs_from_system = ssl_ca_certs_from_system
+        @topic                    = topic
+        @partition                = partition
+        @partition_key            = partition_key
+        @key                      = key
+        @delivery_threshold       = delivery_threshold
+        @delivery_interval        = delivery_interval
+        @required_acks            = required_acks
 
         super(metrics: metrics, **args, &block)
         reopen
@@ -141,19 +150,21 @@ module SemanticLogger
 
       def reopen
         @kafka = ::Kafka.new(
-          seed_brokers:        seed_brokers,
-          client_id:           client_id,
-          connect_timeout:     connect_timeout,
-          socket_timeout:      socket_timeout,
-          ssl_ca_cert:         ssl_ca_cert,
-          ssl_client_cert:     ssl_client_cert,
-          ssl_client_cert_key: ssl_client_cert_key,
-          logger:              logger
+          seed_brokers:             seed_brokers,
+          client_id:                client_id,
+          connect_timeout:          connect_timeout,
+          socket_timeout:           socket_timeout,
+          ssl_ca_cert:              ssl_ca_cert,
+          ssl_client_cert:          ssl_client_cert,
+          ssl_client_cert_key:      ssl_client_cert_key,
+          ssl_ca_certs_from_system: ssl_ca_certs_from_system,
+          logger:                   logger
         )
 
         @producer = @kafka.async_producer(
           delivery_threshold: delivery_threshold,
-          delivery_interval:  delivery_interval
+          delivery_interval:  delivery_interval,
+          required_acks:      required_acks
         )
       end
 
@@ -183,6 +194,10 @@ module SemanticLogger
           delivery_interval:  delivery_interval
         )
       end
+
+      private
+
+      attr_reader :producer
     end
   end
 end

data/lib/semantic_logger/appender/mongodb.rb

@@ -1,8 +1,8 @@
-require 'socket'
+require "socket"
 begin
-  require 'mongo'
+  require "mongo"
 rescue LoadError
-  raise 'Gem mongo is required for logging to MongoDB. Please add the gem "mongo" v2.0 or greater to your Gemfile.'
+  raise LoadError, 'Gem mongo is required for logging to MongoDB. Please add the gem "mongo" v2.0 or greater to your Gemfile.'
 end
 
 module SemanticLogger
@@ -104,9 +104,9 @@ module SemanticLogger
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
       def initialize(uri:,
-                     collection_name: 'semantic_logger',
+                     collection_name: "semantic_logger",
                      write_concern: 0,
-                     collection_size: 1024 ** 3,
+                     collection_size: 1024**3,
                      collection_max: nil,
                      **args,
                      &block)
@@ -118,7 +118,7 @@ module SemanticLogger
           size:   collection_size,
           write:  {w: write_concern}
         }
-        @options[:max]   = collection_max if collection_max
+        @options[:max] = collection_max if collection_max
 
         reopen
 

data/lib/semantic_logger/appender/new_relic.rb

@@ -1,7 +1,7 @@
 begin
-  require 'newrelic_rpm'
+  require "newrelic_rpm"
 rescue LoadError
-  raise 'Gem newrelic_rpm is required for logging to New Relic. Please add the gem "newrelic_rpm" to your Gemfile.'
+  raise LoadError, 'Gem newrelic_rpm is required for logging to New Relic. Please add the gem "newrelic_rpm" to your Gemfile.'
 end
 
 # Send log messages to NewRelic

data/lib/semantic_logger/appender/rabbitmq.rb

@@ -1,7 +1,7 @@
 begin
-  require 'bunny'
+  require "bunny"
 rescue LoadError
-  raise 'Gem bunny is required for logging to RabbitMQ. Please add the gem "bunny" to your Gemfile.'
+  raise LoadError, 'Gem bunny is required for logging to RabbitMQ. Please add the gem "bunny" to your Gemfile.'
 end
 
 # Forward all log messages to RabbitMQ.
@@ -14,7 +14,7 @@ end
 #     # Name of the queue in RabbitMQ where to publish the logs. This queue will be bound to "amqp.direct" exchange.
 #     queue: 'semantic_logger',
 #
-#     # This host will be used for RabbitMQ connection. 
+#     # This host will be used for RabbitMQ connection.
 #     # NOTE this is different than :host option which is used by the logger directly.
 #     rabbitmq_host: '127.0.0.1',
 #
@@ -63,7 +63,7 @@ module SemanticLogger
       # RabbitMQ Parameters:
       #
       #   rabbitmq_host: [String]
-      #     Host for AMQP connection. in Bunny this is called :host but here it has 
+      #     Host for AMQP connection. in Bunny this is called :host but here it has
       #     been remapped to avoid conflicting with SemanticLogger's :host param.
       #     Default: localhost
       #
@@ -76,7 +76,7 @@ module SemanticLogger
       #     Default: nil
       #
       #   more parameters supported by Bunny: http://rubybunny.info/articles/connecting.html
-      def initialize(queue_name: 'semantic_logger', rabbitmq_host: nil, metrics: false, **args, &block)
+      def initialize(queue_name: "semantic_logger", rabbitmq_host: nil, metrics: false, **args, &block)
         @queue_name             = queue_name
         @rabbitmq_args          = args.dup
         @rabbitmq_args[:host]   = rabbitmq_host

data/lib/semantic_logger/appender/sentry.rb

@@ -1,7 +1,7 @@
 begin
-  require 'sentry-raven'
+  require "sentry-raven"
 rescue LoadError
-  raise 'Gem sentry-raven is required for logging purposes. Please add the gem "sentry-raven" to your Gemfile.'
+  raise LoadError, 'Gem sentry-raven is required for logging purposes. Please add the gem "sentry-raven" to your Gemfile.'
 end
 
 # Send log messages to sentry
@@ -46,12 +46,12 @@ module SemanticLogger
       # Send an error notification to sentry
       def log(log)
         # Ignore logs coming from Raven itself
-        return false if log.name == 'Raven'
+        return false if log.name == "Raven"
 
-        context = formatter.call(log, self)
-        user = context.delete(:user)
-        tags = context.delete(:tags)
-        attrs = {
+        context      = formatter.call(log, self)
+        user         = context.delete(:user)
+        tags         = context.delete(:tags)
+        attrs        = {
           level: context.delete(:level),
           extra: context
         }

data/lib/semantic_logger/appender/sentry_ruby.rb

@@ -0,0 +1,138 @@
+begin
+  require "sentry-ruby"
+rescue LoadError
+  raise LoadError, 'Gem sentry-ruby is required for logging purposes. Please add the gem "sentry-ruby" to your Gemfile.'
+end
+
+# Send log messages to sentry
+#
+# Example:
+#   SemanticLogger.add_appender(appender: :sentry_ruby)
+#
+module SemanticLogger
+  module Appender
+    class SentryRuby < 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(level: :error, **args, &block)
+        # Replace the Sentry Ruby logger so that we can identify its log
+        # messages and not forward them to Sentry
+        ::Sentry.init { |config| config.logger = SemanticLogger[::Sentry] } unless ::Sentry.initialized?
+        super(level: level, **args, &block)
+      end
+
+      # Send an error notification to sentry
+      def log(log)
+        # Ignore logs coming from Sentry itself
+        return false if log.name == "Sentry"
+
+        context = formatter.call(log, self)
+        payload = context.delete(:payload) || {}
+        named_tags = context[:named_tags] || {}
+        transaction_name = named_tags.delete(:transaction_name)
+
+        user = extract_user!(named_tags, payload)
+        tags = extract_tags!(context)
+
+        fingerprint = payload.delete(:fingerprint)
+
+        ::Sentry.with_scope do |scope|
+          scope.set_user(user) if user
+          scope.set_level(context.delete(:level)) if context[:level]
+          scope.set_fingerprint(fingerprint) if fingerprint
+          scope.set_transaction_name(transaction_name) if transaction_name
+          scope.set_tags(tags)
+          scope.set_extras(context)
+          scope.set_extras(payload)
+
+          if log.exception
+            ::Sentry.capture_exception(log.exception)
+          elsif log.backtrace
+            ::Sentry.capture_message(context[:message], backtrace: log.backtrace)
+          else
+            ::Sentry.capture_message(context[:message])
+          end
+        end
+
+        true
+      end
+
+      private
+
+      # Use Raw Formatter by default
+      def default_formatter
+        SemanticLogger::Formatters::Raw.new
+      end
+
+      # Extract user data from named tags or payload.
+      #
+      # Keys :user_id and :user_email will be used as :id and :email respectively.
+      # Keys :username and :ip_address will be used verbatim.
+      #
+      # Any additional value nested in a :user key will be added, provided any of
+      # the above keys is already present.
+      #
+      def extract_user!(*sources)
+        keys = {user_id: :id, username: :username, user_email: :email, ip_address: :ip_address}
+
+        user = {}
+
+        sources.each do |source|
+          keys.each do |source_key, target_key|
+            value = source.delete(source_key)
+            user[target_key] = value if value
+          end
+        end
+
+        return if user.empty?
+
+        sources.each do |source|
+          extras = source.delete(:user)
+          user.merge!(extras) if extras.is_a?(Hash)
+        end
+
+        user
+      end
+
+      # Extract tags.
+      #
+      # Named tags will be stringified (both key and value).
+      # Unnamed tags will be stringified and joined with a comma. Then they will
+      # be used as a "tag" named tag. If such a tag already exists, it is also
+      # joined with a comma.
+      #
+      # Finally, the tag names are limited to 32 characters and the tag values to 256.
+      #
+      def extract_tags!(context)
+        named_tags = context.delete(:named_tags) || {}
+        named_tags = named_tags.map { |k, v| [k.to_s, v.to_s] }.to_h
+        tags = context.delete(:tags)
+        named_tags.merge!("tag" => tags.join(", ")) { |_, v1, v2| "#{v1}, #{v2}" } if tags
+        named_tags.map { |k, v| [k[0...32], v[0...256]] }.to_h
+      end
+    end
+  end
+end

data/lib/semantic_logger/appender/splunk.rb

@@ -1,7 +1,8 @@
 begin
-  require 'splunk-sdk-ruby'
+  require "splunk-sdk-ruby"
 rescue LoadError
-  raise 'Gem splunk-sdk-ruby is required for logging to Splunk. Please add the gem "splunk-sdk-ruby" to your Gemfile.'
+  raise LoadError,
+        'Gem splunk-sdk-ruby is required for logging to Splunk. Please add the gem "splunk-sdk-ruby" to your Gemfile.'
 end
 
 # Splunk log appender.
@@ -88,7 +89,7 @@ module SemanticLogger
       #     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.
-      def initialize(index: 'main', source_type: nil, **args, &block)
+      def initialize(index: "main", source_type: nil, **args, &block)
         @index       = index
         @source_type = source_type
 
@@ -120,14 +121,15 @@ module SemanticLogger
       def call(log, logger)
         h = SemanticLogger::Formatters::Raw.new.call(log, logger)
         h.delete(:time)
-        message               = {
+        message = {
           source:  logger.application,
           host:    logger.host,
           time:    log.time.utc.to_f,
           message: h.delete(:message),
           event:   h
         }
-        message[:sourcetype] = source_type if source_type
+        message[:environment] = logger.environment if logger.environment
+        message[:sourcetype]  = source_type if source_type
         message
       end
     end

data/lib/semantic_logger/appender/splunk_http.rb

@@ -1,4 +1,4 @@
-require 'json'
+require "json"
 # Splunk log appender using the Splunk HTTP(S) listener.
 #
 # Use the newer, faster and more complete JSON over HTTP interface for Splunk.
@@ -81,16 +81,17 @@ module SemanticLogger
         super(compress: compress, **args, &block)
 
         # Put splunk auth token in the header of every HTTP post.
-        @header['Authorization'] = "Splunk #{token}"
+        @header["Authorization"] = "Splunk #{token}"
       end
 
       # Returns [String] JSON to send to Splunk.
       #
       # For splunk format requirements see:
-      #   http://dev.splunk.com/view/event-collector/SP-CAAAE6P
+      #   https://docs.splunk.com/Documentation/Splunk/latest/Data/FormateventsforHTTPEventCollector
       def call(log, logger)
-        h                     = SemanticLogger::Formatters::Raw.new(time_format: :seconds).call(log, logger)
-        message               = {
+        h = SemanticLogger::Formatters::Raw.new(time_format: :seconds).call(log, logger)
+        h.delete(:host)
+        message = {
           source: logger.application,
           host:   logger.host,
           time:   h.delete(:time),

data/lib/semantic_logger/appender/syslog.rb

@@ -1,6 +1,6 @@
-require 'syslog'
-require 'uri'
-require 'socket'
+require "syslog"
+require "uri"
+require "socket"
 # Send log messages to local syslog, or remote syslog servers over TCP or UDP.
 #
 # Example:
@@ -31,7 +31,7 @@ require 'socket'
 module SemanticLogger
   module Appender
     class Syslog < SemanticLogger::Subscriber
-      attr_reader :remote_syslog, :url, :server, :port, :protocol, :facility, :options, :level_map
+      attr_reader :remote_syslog, :url, :server, :port, :protocol, :facility, :options, :level_map, :max_size
 
       # Create a Syslog appender instance.
       #
@@ -57,7 +57,7 @@ module SemanticLogger
       #     Only used with the TCP protocol.
       #     Specify custom parameters to pass into Net::TCPClient.new
       #     For a list of options see the net_tcp_client documentation:
-      #       https://github.com/rocketjob/net_tcp_client/blob/master/lib/net/tcp_client/tcp_client.rb
+      #       https://github.com/reidmorrison/net_tcp_client/blob/master/lib/net/tcp_client/tcp_client.rb
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
       #     Override the log level for this appender.
@@ -73,6 +73,10 @@ module SemanticLogger
       #     Identity of the program.
       #     Default: SemanticLogger.application
       #
+      #   max_size: [Integer]
+      #     Set your own packet size.
+      #     Default: 1024 bytes
+      #
       #   options: [Integer]
       #     Default: ::Syslog::LOG_PID | ::Syslog::LOG_CONS
       #     Any of the following (options can be logically OR'd together)
@@ -119,8 +123,9 @@ module SemanticLogger
       #   Example:
       #     # Change the warn level to LOG_NOTICE level instead of a the default of LOG_WARNING.
       #     SemanticLogger.add_appender(appender: :syslog, level_map: {warn: ::Syslog::LOG_NOTICE})
-      def initialize(url: 'syslog://localhost',
+      def initialize(url: "syslog://localhost",
                      facility: ::Syslog::LOG_USER,
+                     max_size: 1024,
                      level_map: SemanticLogger::Formatters::Syslog::LevelMap.new,
                      options: ::Syslog::LOG_PID | ::Syslog::LOG_CONS,
                      tcp_client: {},
@@ -129,13 +134,14 @@ module SemanticLogger
 
         @options            = options
         @facility           = facility
+        @max_size           = max_size
         @level_map          = level_map
         @url                = url
         uri                 = URI(@url)
-        @server             = uri.host || 'localhost'
+        @server             = uri.host || "localhost"
         @protocol           = (uri.scheme || :syslog).to_sym
         @port               = uri.port || 514
-        @server             = 'localhost' if @protocol == :syslog
+        @server             = "localhost" if @protocol == :syslog
         @tcp_client_options = tcp_client
 
         raise "Unknown protocol #{@protocol}!" unless %i[syslog tcp udp].include?(@protocol)
@@ -143,17 +149,19 @@ module SemanticLogger
         # The syslog_protocol gem is required when logging over TCP or UDP.
         if %i[tcp udp].include?(@protocol)
           begin
-            require 'syslog_protocol'
+            require "syslog_protocol"
           rescue LoadError
-            raise 'Missing gem: syslog_protocol. This gem is required when logging over TCP or UDP. To fix this error: gem install syslog_protocol'
+            raise LoadError,
+                  "Missing gem: syslog_protocol. This gem is required when logging over TCP or UDP. To fix this error: gem install syslog_protocol"
           end
 
           # The net_tcp_client gem is required when logging over TCP.
           if protocol == :tcp
             begin
-              require 'net/tcp_client'
+              require "net/tcp_client"
             rescue LoadError
-              raise 'Missing gem: net_tcp_client. This gem is required when logging over TCP. To fix this error: gem install net_tcp_client'
+              raise LoadError,
+                    "Missing gem: net_tcp_client. This gem is required when logging over TCP. To fix this error: gem install net_tcp_client"
             end
           end
         end
@@ -171,7 +179,7 @@ module SemanticLogger
           ::Syslog.send(method, application, options, facility)
         when :tcp
           @tcp_client_options[:server] = "#{@server}:#{@port}"
-          @remote_syslog               = Net::TCPClient.new(@tcp_client_options)
+          @remote_syslog               = Net::TCPClient.new(**@tcp_client_options)
           # Use the local logger for @remote_syslog so errors with the remote logger can be recorded locally.
           @remote_syslog.logger = logger
         when :udp
@@ -186,7 +194,7 @@ module SemanticLogger
         case @protocol
         when :syslog
           # Since the Ruby Syslog API supports sprintf format strings, double up all existing '%'
-          message = formatter.call(log, self).gsub '%', '%%'
+          message = formatter.call(log, self).gsub "%", "%%"
           ::Syslog.log @level_map[log.level], message
         when :tcp
           @remote_syslog.retry_on_connection_failure { @remote_syslog.write("#{formatter.call(log, self)}\r\n") }
@@ -209,7 +217,7 @@ module SemanticLogger
           # Format is text output without the time
           SemanticLogger::Formatters::Default.new(time_format: nil)
         else
-          SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map)
+          SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map, max_size: max_size)
         end
       end
     end

data/lib/semantic_logger/appender/tcp.rb

@@ -1,10 +1,10 @@
 begin
-  require 'net/tcp_client'
+  require "net/tcp_client"
 rescue LoadError
-  raise 'Gem net_tcp_client is required for logging over TCP. Please add the gem "net_tcp_client" to your Gemfile.'
+  raise LoadError, 'Gem net_tcp_client is required for logging over TCP. Please add the gem "net_tcp_client" to your Gemfile.'
 end
 
-raise 'Net::TCPClient v2.0 or greater is required to log over TCP' unless Net::TCPClient::VERSION.to_f >= 2.0
+raise "Net::TCPClient v2.0 or greater is required to log over TCP" unless Net::TCPClient::VERSION.to_f >= 2.0
 
 module SemanticLogger
   module Appender
@@ -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,23 +182,23 @@ 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
 
         # Use the internal logger so that errors with remote logging are only written locally.
         Net::TCPClient.logger      = logger
-        Net::TCPClient.logger.name = 'Net::TCPClient'
+        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
 
       # After forking an active process call #reopen to re-open the handles to resources.
       def reopen
         close
-        @tcp_client = Net::TCPClient.new(@tcp_client_args)
+        @tcp_client = Net::TCPClient.new(**@tcp_client_args)
       end
 
       # Write the log using the specified protocol and server.

data/lib/semantic_logger/appender/udp.rb

@@ -1,4 +1,4 @@
-require 'socket'
+require "socket"
 module SemanticLogger
   module Appender
     # UDP log appender.
@@ -74,7 +74,7 @@ module SemanticLogger
       def reopen
         close
         @socket    = UDPSocket.new
-        host, port = server.split(':')
+        host, port = server.split(":")
         @socket.connect(host, port.to_i)
       end
 

data/lib/semantic_logger/appender/wrapper.rb

@@ -32,7 +32,7 @@ module SemanticLogger
       #    require 'logger'
       #    require 'semantic_logger'
       #
-      #    ruby_logger = Logger.new(STDOUT)
+      #    ruby_logger = Logger.new($stdout)
       #    SemanticLogger.add_appender(logger: ruby_logger)
       #
       #    logger =  SemanticLogger['test']
@@ -45,7 +45,8 @@ module SemanticLogger
         # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
         does_not_implement = LEVELS[1..-1].find { |i| !@logger.respond_to?(i) }
         if does_not_implement
-          raise(ArgumentError, "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}")
+          raise(ArgumentError,
+                "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}")
         end
 
         super(**args, &block)