fluent-plugin-scalyr 0.8.10 → 0.8.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 607dd0cf45280387ab9c19b460eab081f2111b1059f8036032e13c1c5c4fd901
-  data.tar.gz: 3d0fa711e084ce2f204dbf69c249363a88d73293a6874c8eb6a175ee920e5cc5
+  metadata.gz: 2d9fa05bade6ec51a39896e90bce7ddfdf233c8888d5ca2ac41393966c8a924b
+  data.tar.gz: b6406c122b1180faa48294b47ed2ebb1b61aad08c64c0310385a00c0ae8a044a
 SHA512:
-  metadata.gz: f6075b808c1126d4b4d8ba7ea30fb5d899facc78c38f4d0d95afc8c97f5eca8f28aefdf414b267dd45695ebe70feb2dd976be76babb8f8458d1240382077a3f0
-  data.tar.gz: deeafb8a4886f51ce635541756e33ba5c3a98b31e6c4ac6f0a5a37a9f8f8862e2a32d0be2026d90f6f7828157e43ac77261529364f1b2bf697b9a2948f7fd3e4
+  metadata.gz: 3b083816314fdf992eaca0cb0216795e2c7a6c1cc7e2f32669452201c45b29d6254dcbc2f69a665d6a0852242423bd87cdf62a88feda5f463e6f774b142d0520
+  data.tar.gz: 8a94b4b649cfd45fa1143e6866d119811236771980f508d0643b0b51b1d6bbdb2e241233a469086a0b5a3e22529c08d1c23b7825966fe78e367defd4672d20c2

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 gemspec

data/README.md

@@ -116,7 +116,7 @@ directory.
 
 ***scalyr_server*** - the Scalyr server to send API requests to. This value is optional and defaults to https://agent.scalyr.com/
 
-***ssl_ca_bundle_path*** - a path on your server pointing to a valid certificate bundle.  This value is optional and defaults to */etc/ssl/certs/ca-bundle.crt*.
+***ssl_ca_bundle_path*** - a path on your server pointing to a valid certificate bundle.  This value is optional and defaults to *nil*, which means it will look for a valid certificate bundle on its own.
 
 **Note:** if the certificate bundle does not contain a certificate chain that verifies the Scalyr SSL certificate then all requests to Scalyr will fail unless ***ssl_verify_peer*** is set to false.  If you suspect logging to Scalyr is failing due to an invalid certificate chain, you can grep through the Fluentd output for warnings that contain the message 'certificate verification failed'.  The full text of such warnings will look something like this:
 
@@ -180,3 +180,22 @@ Which builds the gem and puts it in the pkg directory, then install the Gem usin
 ```
 fluent-gem install pkg/fluent-plugin-scalyr-<VERSION>.gem
 ```
+
+Publishing a new release to RubyGems
+------------------------------------
+
+(for project maintainers)
+
+To publish a new version to RubyGems, simply make your changes, make sure all the lint checks and
+tests pass and merge your changes into master.
+
+After that's done, bump a version in ``VERSION`` file, update ``CHANGELOG.md`` file, add a tag
+which matches a version in VERSION file (e.g. ``v0.8.10``) and push that tag to the remote:
+
+```bash
+git tag v0.8.10
+git push origin v0.8.10
+```
+
+Push of this tag will trigger a Circle CI job which will build the latest version of the gem and
+publish it to RubyGems.

data/Rakefile

@@ -1,11 +1,14 @@
-require 'bundler'
+# frozen_string_literal: true
+
+require "bundler"
 Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
+require "rake/testtask"
 
-Rake::TestTask.new do |t|
-  t.libs << "test" << "lib"
-  t.pattern = 'test/**/test_*.rb'
+Rake::TestTask.new(:test) do |test|
+  test.libs << "lib" << "test"
+  test.test_files = FileList["test/test_*.rb"]
+  test.verbose = true
 end
 
-task :default => [:build]
+task default: [:build]

data/VERSION

@@ -1 +1 @@
-0.8.10
+0.8.11

data/fluent-plugin-scalyr.gemspec

@@ -1,4 +1,6 @@
-$:.push File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path("lib", __dir__)
 
 Gem::Specification.new do |gem|
   gem.name = "fluent-plugin-scalyr"
@@ -10,16 +12,18 @@ Gem::Specification.new do |gem|
   gem.licenses = ["Apache-2.0"]
   gem.email = "imron@scalyr.com"
   gem.platform = Gem::Platform::RUBY
-  gem.files = Dir['AUTHORS', 'Gemfile', 'LICENSE', 'README.md', 'Rakefile', 'VERSION', 'fluent-plugin-scalyr.gemspec', 'fluent.conf.sample', 'lib/**/*', 'test/**/*']
+  gem.files = Dir["AUTHORS", "Gemfile", "LICENSE", "README.md", "Rakefile", "VERSION",
+                  "fluent-plugin-scalyr.gemspec", "fluent.conf.sample", "lib/**/*", "test/**/*"]
   gem.test_files = Dir.glob("{test,spec,features}/**/*")
-  gem.executables = Dir.glob("bin/*").map{ |f| File.basename(f) }
-  gem.require_paths = ['lib']
-  gem.add_dependency "fluentd", [">= 0.14.0", "< 2"]
+  gem.executables = Dir.glob("bin/*").map {|f| File.basename(f) }
+  gem.require_paths = ["lib"]
   gem.add_dependency "ffi", "1.9.25"
+  gem.add_dependency "fluentd", [">= 0.14.0", "< 2"]
   gem.add_dependency "rbzip2", "0.3.0"
   gem.add_dependency "zlib"
+  gem.add_development_dependency "bundler", "~> 1.9"
+  gem.add_development_dependency "flexmock", "~> 1.2"
   gem.add_development_dependency "rake", "~> 0.9"
+  gem.add_development_dependency "rubocop", "~> 0.4"
   gem.add_development_dependency "test-unit", "~> 3.0"
-  gem.add_development_dependency "flexmock", "~> 1.2"
-  gem.add_development_dependency "bundler", "~> 1.9"
 end

data/lib/fluent/plugin/out_scalyr.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Scalyr Output Plugin for Fluentd
 #
@@ -15,47 +17,44 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
-require 'fluent/plugin/output'
-require 'fluent/plugin/scalyr-exceptions'
-require 'fluent/plugin_helper/compat_parameters'
-require 'json'
-require 'net/http'
-require 'net/https'
-require 'rbzip2'
-require 'stringio'
-require 'zlib'
-require 'securerandom'
-require 'socket'
-require 'thread'
-
+require "fluent/plugin/output"
+require "fluent/plugin/scalyr_exceptions"
+require "fluent/plugin_helper/compat_parameters"
+require "json"
+require "net/http"
+require "net/https"
+require "rbzip2"
+require "stringio"
+require "zlib"
+require "securerandom"
+require "socket"
 module Scalyr
   class ScalyrOut < Fluent::Plugin::Output
-    Fluent::Plugin.register_output( 'scalyr', self )
+    Fluent::Plugin.register_output("scalyr", self)
     helpers :compat_parameters
     helpers :event_emitter
 
     config_param :api_write_token, :string
-    config_param :server_attributes, :hash, :default => nil
-    config_param :use_hostname_for_serverhost, :bool, :default => true
-    config_param :scalyr_server, :string, :default => "https://agent.scalyr.com/"
-    config_param :ssl_ca_bundle_path, :string, :default => "/etc/ssl/certs/ca-bundle.crt"
-    config_param :ssl_verify_peer, :bool, :default => true
-    config_param :ssl_verify_depth, :integer, :default => 5
-    config_param :message_field, :string, :default => "message"
-    config_param :max_request_buffer, :integer, :default => 5500000
-    config_param :force_message_encoding, :string, :default => nil
-    config_param :replace_invalid_utf8, :bool, :default => false
-    config_param :compression_type, :string, :default => nil #Valid options are bz2, deflate or None. Defaults to None.
-    config_param :compression_level, :integer, :default => 6 #An int containing the compression level of compression to use, from 1-9. Defaults to 6
+    config_param :server_attributes, :hash, default: nil
+    config_param :use_hostname_for_serverhost, :bool, default: true
+    config_param :scalyr_server, :string, default: "https://agent.scalyr.com/"
+    config_param :ssl_ca_bundle_path, :string, default: nil
+    config_param :ssl_verify_peer, :bool, default: true
+    config_param :ssl_verify_depth, :integer, default: 5
+    config_param :message_field, :string, default: "message"
+    config_param :max_request_buffer, :integer, default: 5_500_000
+    config_param :force_message_encoding, :string, default: nil
+    config_param :replace_invalid_utf8, :bool, default: false
+    config_param :compression_type, :string, default: nil # Valid options are bz2, deflate or None. Defaults to None.
+    config_param :compression_level, :integer, default: 6 # An int containing the compression level of compression to use, from 1-9. Defaults to 6
 
     config_section :buffer do
-      config_set_default :retry_max_times, 40 #try a maximum of 40 times before discarding
-      config_set_default :retry_max_interval,  30 #wait a maximum of 30 seconds per retry
-      config_set_default :retry_wait, 5 #wait a minimum of 5 seconds per retry
-      config_set_default :flush_interval, 5 #default flush interval of 5 seconds
-      config_set_default :chunk_limit_size, 2500000 #default chunk size of 2.5mb
-      config_set_default :queue_limit_length, 1024 #default queue size of 1024
+      config_set_default :retry_max_times, 40 # try a maximum of 40 times before discarding
+      config_set_default :retry_max_interval, 30 # wait a maximum of 30 seconds per retry
+      config_set_default :retry_wait, 5 # wait a minimum of 5 seconds per retry
+      config_set_default :flush_interval, 5 # default flush interval of 5 seconds
+      config_set_default :chunk_limit_size, 2_500_000 # default chunk size of 2.5mb
+      config_set_default :queue_limit_length, 1024 # default queue size of 1024
     end
 
     # support for version 0.14.0:
@@ -71,46 +70,45 @@ module Scalyr
       true
     end
 
-    def configure( conf )
-
-      if conf.elements('buffer').empty?
-        $log.warn "Pre 0.14.0 configuration file detected.  Please consider updating your configuration file"
+    def configure(conf)
+      if conf.elements("buffer").empty?
+        $log.warn "Pre 0.14.0 configuration file detected.  Please consider updating your configuration file" # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
       end
 
-      compat_parameters_buffer( conf, default_chunk_key: '' )
+      compat_parameters_buffer(conf, default_chunk_key: "")
 
       super
 
-      if @buffer.chunk_limit_size > 6000000
-        $log.warn "Buffer chunk size is greater than 6Mb.  This may result in requests being rejected by Scalyr"
+      if @buffer.chunk_limit_size > 6_000_000
+        $log.warn "Buffer chunk size is greater than 6Mb.  This may result in requests being rejected by Scalyr" # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
       end
 
-      if @max_request_buffer > 6000000
-        $log.warn "Maximum request buffer > 6Mb.  This may result in requests being rejected by Scalyr"
+      if @max_request_buffer > 6_000_000
+        $log.warn "Maximum request buffer > 6Mb.  This may result in requests being rejected by Scalyr" # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
       end
 
       @message_encoding = nil
-      if @force_message_encoding.to_s != ''
+      if @force_message_encoding.to_s != ""
         begin
-          @message_encoding = Encoding.find( @force_message_encoding )
+          @message_encoding = Encoding.find(@force_message_encoding)
           $log.debug "Forcing message encoding to '#{@force_message_encoding}'"
         rescue ArgumentError
           $log.warn "No encoding '#{@force_message_encoding}' found.  Ignoring"
         end
       end
 
-      #evaluate any statements in string value of the server_attributes object
+      # evaluate any statements in string value of the server_attributes object
       if @server_attributes
         new_attributes = {}
         @server_attributes.each do |key, value|
-          if value.is_a?( String )
-            m = /^\#{(.*)}$/.match( value )
-            if m
-              new_attributes[key] = eval( m[1] )
-            else
-              new_attributes[key] = value
-            end
-          end
+          next unless value.is_a?(String)
+
+          m = /^\#{(.*)}$/.match(value)
+          new_attributes[key] = if m
+                                  eval(m[1]) # rubocop:disable Security/Eval
+                                else
+                                  value
+                                end
         end
         @server_attributes = new_attributes
       end
@@ -119,143 +117,131 @@ module Scalyr
       if @use_hostname_for_serverhost
 
         # ensure server_attributes is not nil
-        if @server_attributes.nil?
-          @server_attributes = {}
-        end
+        @server_attributes = {} if @server_attributes.nil?
 
         # only set serverHost if it doesn't currently exist in server_attributes
         # Note: Use strings rather than symbols for the key, because keys coming
         # from the config file will be strings
-        if !@server_attributes.key? 'serverHost'
-          @server_attributes['serverHost'] = Socket.gethostname
+        unless @server_attributes.key? "serverHost"
+          @server_attributes["serverHost"] = Socket.gethostname
         end
       end
 
-      @scalyr_server << '/' unless @scalyr_server.end_with?('/')
+      @scalyr_server << "/" unless @scalyr_server.end_with?("/")
 
       @add_events_uri = URI @scalyr_server + "addEvents"
 
       num_threads = @buffer_config.flush_thread_count
 
-      #forcibly limit the number of threads to 1 for now, to ensure requests always have incrementing timestamps
-      raise Fluent::ConfigError, "num_threads is currently limited to 1. You specified #{num_threads}." if num_threads > 1
+      # forcibly limit the number of threads to 1 for now, to ensure requests always have incrementing timestamps
+      if num_threads > 1
+        raise Fluent::ConfigError, "num_threads is currently limited to 1. You specified #{num_threads}."
+      end
     end
 
     def start
       super
-      #Generate a session id.  This will be called once for each <match> in fluent.conf that uses scalyr
+      # Generate a session id.  This will be called once for each <match> in fluent.conf that uses scalyr
       @session = SecureRandom.uuid
 
-      $log.info "Scalyr Fluentd Plugin ID id=#{self.plugin_id()} worker=#{fluentd_worker_id} session=#{@session}"
-
+      $log.info "Scalyr Fluentd Plugin ID id=#{plugin_id} worker=#{fluentd_worker_id} session=#{@session}" # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
     end
 
-    def format( tag, time, record )
-      begin
-
-        if time.nil?
-          time = Fluent::Engine.now
-        end
-
-        # handle timestamps that are not EventTime types
-        if time.is_a?( Integer )
-          time = Fluent::EventTime.new( time )
-        elsif time.is_a?( Float )
-          components = time.divmod 1 #get integer and decimal components
-          sec = components[0].to_i
-          nsec = (components[1] * 10**9).to_i
-          time = Fluent::EventTime.new( sec, nsec )
-        end
+    def format(tag, time, record)
+      time = Fluent::Engine.now if time.nil?
+
+      # handle timestamps that are not EventTime types
+      if time.is_a?(Integer)
+        time = Fluent::EventTime.new(time)
+      elsif time.is_a?(Float)
+        components = time.divmod 1 # get integer and decimal components
+        sec = components[0].to_i
+        nsec = (components[1] * 10**9).to_i
+        time = Fluent::EventTime.new(sec, nsec)
+      end
 
-        if @message_field != "message"
-          if record.key? @message_field
-            if record.key? "message"
-              $log.warn "Overwriting log record field 'message'.  You are seeing this warning because in your fluentd config file you have configured the '#{@message_field}' field to be converted to the 'message' field, but the log record already contains a field called 'message' and this is now being overwritten."
-            end
-            record["message"] = record[@message_field]
-            record.delete( @message_field )
+      if @message_field != "message"
+        if record.key? @message_field
+          if record.key? "message"
+            $log.warn "Overwriting log record field 'message'.  You are seeing this warning because in your fluentd config file you have configured the '#{@message_field}' field to be converted to the 'message' field, but the log record already contains a field called 'message' and this is now being overwritten." # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
           end
+          record["message"] = record[@message_field]
+          record.delete(@message_field)
         end
+      end
 
-        if @message_encoding and record.key? "message" and record["message"]
-          if @replace_invalid_utf8 and @message_encoding == Encoding::UTF_8
-            record["message"] = record["message"].encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => "<?>").force_encoding('UTF-8')
-          else
-            record["message"].force_encoding( @message_encoding )
-          end
+      if @message_encoding && record.key?("message") && record["message"]
+        if @replace_invalid_utf8 && (@message_encoding == Encoding::UTF_8)
+          record["message"] = record["message"].encode("UTF-8", invalid: :replace, undef: :replace, replace: "<?>").force_encoding("UTF-8") # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
+        else
+          record["message"].force_encoding(@message_encoding)
         end
-        [tag, time.sec, time.nsec, record].to_msgpack
-
-      rescue JSON::GeneratorError
-        $log.warn "Unable to format message due to JSON::GeneratorError.  Record is:\n\t#{record.to_s}"
-        raise
       end
+      [tag, time.sec, time.nsec, record].to_msgpack
+    rescue JSON::GeneratorError
+      $log.warn "Unable to format message due to JSON::GeneratorError.  Record is:\n\t#{record}"
+      raise
     end
 
-    #called by fluentd when a chunk of log messages is ready
-    def write( chunk )
-      begin
-        $log.debug "Size of chunk is: #{chunk.size}"
-        requests = self.build_add_events_body( chunk )
-        $log.debug "Chunk split into #{requests.size} request(s)."
-
-        requests.each_with_index { |request, index|
-          $log.debug "Request #{index + 1}/#{requests.size}: #{request[:body].bytesize} bytes"
-          begin
-            response = self.post_request( @add_events_uri, request[:body] )
-            self.handle_response( response )
-          rescue OpenSSL::SSL::SSLError => e
-            if e.message.include? "certificate verify failed"
-              $log.warn "SSL certificate verification failed.  Please make sure your certificate bundle is configured correctly and points to a valid file. You can configure this with the ssl_ca_bundle_path configuration option. The current value of ssl_ca_bundle_path is '#{@ssl_ca_bundle_path}'"
-            end
-            $log.warn e.message
-            $log.warn "Discarding buffer chunk without retrying or logging to <secondary>"
-          rescue Scalyr::Client4xxError => e
-            $log.warn "4XX status code received for request #{index + 1}/#{requests.size}.  Discarding buffer without retrying or logging.\n\t#{response.code} - #{e.message}\n\tChunk Size: #{chunk.size}\n\tLog messages this request: #{request[:record_count]}\n\tJSON payload size: #{request[:body].bytesize}\n\tSample: #{request[:body][0,1024]}..."
+    # called by fluentd when a chunk of log messages is ready
+    def write(chunk)
+      $log.debug "Size of chunk is: #{chunk.size}"
+      requests = build_add_events_body(chunk)
+      $log.debug "Chunk split into #{requests.size} request(s)."
 
+      requests.each_with_index {|request, index|
+        $log.debug "Request #{index + 1}/#{requests.size}: #{request[:body].bytesize} bytes"
+        begin
+          response = post_request(@add_events_uri, request[:body])
+          handle_response(response)
+        rescue OpenSSL::SSL::SSLError => e
+          if e.message.include? "certificate verify failed"
+            $log.warn "SSL certificate verification failed.  Please make sure your certificate bundle is configured correctly and points to a valid file. You can configure this with the ssl_ca_bundle_path configuration option. The current value of ssl_ca_bundle_path is '#{@ssl_ca_bundle_path}'" # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
           end
-        }
-
-      rescue JSON::GeneratorError
-        $log.warn "Unable to format message due to JSON::GeneratorError."
-        raise
-      end
+          $log.warn e.message
+          $log.warn "Discarding buffer chunk without retrying or logging to <secondary>"
+        rescue Scalyr::Client4xxError => e
+          $log.warn "4XX status code received for request #{index + 1}/#{requests.size}.  Discarding buffer without retrying or logging.\n\t#{response.code} - #{e.message}\n\tChunk Size: #{chunk.size}\n\tLog messages this request: #{request[:record_count]}\n\tJSON payload size: #{request[:body].bytesize}\n\tSample: #{request[:body][0, 1024]}..."
+        end
+      }
+    rescue JSON::GeneratorError
+      $log.warn "Unable to format message due to JSON::GeneratorError."
+      raise
     end
 
-
-    #explicit function to convert to nanoseconds
-    #will make things easier to maintain if/when fluentd supports higher than second resolutions
-    def to_nanos( seconds, nsec )
+    # explicit function to convert to nanoseconds
+    # will make things easier to maintain if/when fluentd supports higher than second resolutions
+    def to_nanos(seconds, nsec)
       (seconds * 10**9) + nsec
     end
 
-    #explicit function to convert to milliseconds
-    #will make things easier to maintain if/when fluentd supports higher than second resolutions
-    def to_millis( timestamp )
+    # explicit function to convert to milliseconds
+    # will make things easier to maintain if/when fluentd supports higher than second resolutions
+    def to_millis(timestamp)
       (timestamp.sec * 10**3) + (timestamp.nsec / 10**6)
     end
 
-    def post_request( uri, body )
-
-      https = Net::HTTP.new( uri.host, uri.port )
+    def post_request(uri, body)
+      https = Net::HTTP.new(uri.host, uri.port)
       https.use_ssl = true
 
-      #verify peers to prevent potential MITM attacks
+      # verify peers to prevent potential MITM attacks
       if @ssl_verify_peer
-        https.ca_file = @ssl_ca_bundle_path
+        https.ca_file = @ssl_ca_bundle_path unless @ssl_ca_bundle_path.nil?
+        https.ssl_version = :TLSv1_2
         https.verify_mode = OpenSSL::SSL::VERIFY_PEER
         https.verify_depth = @ssl_verify_depth
       end
 
-      #use compression if enabled
+      # use compression if enabled
       encoding = nil
 
       if @compression_type
-        if @compression_type == 'deflate'
-          encoding = 'deflate'
+        if @compression_type == "deflate"
+          encoding = "deflate"
           body = Zlib::Deflate.deflate(body, @compression_level)
-        elsif @compression_type == 'bz2'
-          encoding = 'bz2'
+        elsif @compression_type == "bz2"
+          encoding = "bz2"
           io = StringIO.new
           bz2 = RBzip2.default_adapter::Compressor.new io
           bz2.write body
@@ -265,91 +251,82 @@ module Scalyr
       end
 
       post = Net::HTTP::Post.new uri.path
-      post.add_field( 'Content-Type', 'application/json' )
+      post.add_field("Content-Type", "application/json")
 
-      if @compression_type
-        post.add_field( 'Content-Encoding', encoding )
-      end
+      post.add_field("Content-Encoding", encoding) if @compression_type
 
       post.body = body
 
-      https.request( post )
-
+      https.request(post)
     end
 
-    def handle_response( response )
+    def handle_response(response)
       $log.debug "Response Code: #{response.code}"
       $log.debug "Response Body: #{response.body}"
 
-      response_hash = Hash.new
+      response_hash = {}
 
       begin
-        response_hash = JSON.parse( response.body )
-      rescue
+        response_hash = JSON.parse(response.body)
+      rescue StandardError
         response_hash["status"] = "Invalid JSON response from server"
       end
 
-      #make sure the JSON reponse has a "status" field
-      if !response_hash.key? "status"
+      # make sure the JSON reponse has a "status" field
+      unless response_hash.key? "status"
         $log.debug "JSON response does not contain status message"
         raise Scalyr::ServerError.new "JSON response does not contain status message"
       end
 
       status = response_hash["status"]
 
-      #4xx codes are handled separately
+      # 4xx codes are handled separately
       if response.code =~ /^4\d\d/
         raise Scalyr::Client4xxError.new status
       else
-        if status != "success"
+        if status != "success" # rubocop:disable Style/IfInsideElse
           if status =~ /discardBuffer/
             $log.warn "Received 'discardBuffer' message from server.  Buffer dropped."
-          elsif status =~ %r"/client/"i
+          elsif status =~ %r{/client/}i
             raise Scalyr::ClientError.new status
-          else #don't check specifically for server, we assume all non-client errors are server errors
+          else # don't check specifically for server, we assume all non-client errors are server errors
             raise Scalyr::ServerError.new status
           end
-        elsif !response.code.include? "200" #response code is a string not an int
+        elsif !response.code.include? "200" # response code is a string not an int
           raise Scalyr::ServerError
         end
       end
-
     end
 
-    def build_add_events_body( chunk )
-
-      #requests
-      requests = Array.new
+    def build_add_events_body(chunk)
+      # requests
+      requests = []
 
-      #set of unique scalyr threads for this chunk
-      current_threads = Hash.new
+      # set of unique scalyr threads for this chunk
+      current_threads = {}
 
-      #byte count
+      # byte count
       total_bytes = 0
 
-      #create a Scalyr event object for each record in the chunk
-      events = Array.new
-      chunk.msgpack_each {|(tag, sec, nsec, record)|
-
-        timestamp = self.to_nanos( sec, nsec )
+      # create a Scalyr event object for each record in the chunk
+      events = []
+      chunk.msgpack_each {|(tag, sec, nsec, record)| # rubocop:disable Metrics/BlockLength
+        timestamp = to_nanos(sec, nsec)
 
         thread_id = tag
 
-        #then update the map of threads for this chunk
+        # then update the map of threads for this chunk
         current_threads[tag] = thread_id
 
-        #add a logfile field if one doesn't exist
-        if !record.key? "logfile"
-          record["logfile"] = "/fluentd/#{tag}"
-        end
+        # add a logfile field if one doesn't exist
+        record["logfile"] = "/fluentd/#{tag}" unless record.key? "logfile"
 
-        #append to list of events
-        event = { :thread => thread_id.to_s,
-                  :ts => timestamp,
-                  :attrs => record
-                }
+        # append to list of events
+        event = {thread: thread_id.to_s,
+                 ts:     timestamp,
+                 attrs:  record}
 
-        #get json string of event to keep track of how many bytes we are sending
+        # get json string of event to keep track of how many bytes we are sending
 
         begin
           event_json = event.to_json
@@ -357,72 +334,65 @@ module Scalyr
           $log.warn "#{e.class}: #{e.message}"
 
           # Send the faulty event to a label @ERROR block and allow to handle it there (output to exceptions file for ex)
-          time = Fluent::EventTime.new( sec, nsec )
+          time = Fluent::EventTime.new(sec, nsec)
           router.emit_error_event(tag, time, record, e)
 
           event[:attrs].each do |key, value|
             $log.debug "\t#{key} (#{value.encoding.name}): '#{value}'"
-            event[:attrs][key] = value.encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => "<?>").force_encoding('UTF-8')
+            event[:attrs][key] = value.encode("UTF-8", invalid: :replace, undef: :replace, replace: "<?>").force_encoding("UTF-8") # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
           end
           event_json = event.to_json
         end
 
-        #generate new request if json size of events in the array exceed maximum request buffer size
+        # generate new request if json size of events in the array exceed maximum request buffer size
         append_event = true
         if total_bytes + event_json.bytesize > @max_request_buffer
-          #make sure we always have at least one event
-          if events.size == 0
+          # make sure we always have at least one event
+          if events.empty?
             events << event
             append_event = false
           end
-          request = self.create_request( events, current_threads )
+          request = create_request(events, current_threads)
           requests << request
 
           total_bytes = 0
-          current_threads = Hash.new
-          events = Array.new
+          current_threads = {}
+          events = []
         end
 
-        #if we haven't consumed the current event already
-        #add it to the end of our array and keep track of the json bytesize
+        # if we haven't consumed the current event already
+        # add it to the end of our array and keep track of the json bytesize
         if append_event
           events << event
           total_bytes += event_json.bytesize
         end
-
       }
 
-      #create a final request with any left over events
-      request = self.create_request( events, current_threads )
+      # create a final request with any left over events
+      request = create_request(events, current_threads)
       requests << request
-
     end
 
-    def create_request( events, current_threads )
-      #build the scalyr thread objects
-      threads = Array.new
+    def create_request(events, current_threads)
+      # build the scalyr thread objects
+      threads = []
       current_threads.each do |tag, id|
-        threads << { :id => id.to_s,
-                     :name => "Fluentd: #{tag}"
-                   }
+        threads << {id:   id.to_s,
+                    name: "Fluentd: #{tag}"}
       end
 
-      current_time = self.to_millis( Fluent::Engine.now )
+      current_time = to_millis(Fluent::Engine.now)
 
-      body = { :token => @api_write_token,
-                  :client_timestamp => current_time.to_s,
-                  :session => @session,
-                  :events => events,
-                  :threads => threads
-                }
+      body = {token:            @api_write_token,
+              client_timestamp: current_time.to_s,
+              session:          @session,
+              events:           events,
+              threads:          threads}
 
-      #add server_attributes hash if it exists
-      if @server_attributes
-        body[:sessionInfo] = @server_attributes
-      end
+      # add server_attributes hash if it exists
+      body[:sessionInfo] = @server_attributes if @server_attributes
 
-      { :body => body.to_json, :record_count => events.size }
+      {body: body.to_json, record_count: events.size}
     end
-
   end
 end