fluent-plugin-scalyr 0.8.11 → 0.8.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d9fa05bade6ec51a39896e90bce7ddfdf233c8888d5ca2ac41393966c8a924b
-  data.tar.gz: b6406c122b1180faa48294b47ed2ebb1b61aad08c64c0310385a00c0ae8a044a
+  metadata.gz: cf7d29d7bd880724b9541793c3b1ee368d47172b88fa919c8ef10c4d8ec9028c
+  data.tar.gz: ad42c0dcb664d9d4c9c2417557733dce293b5af51a52978b5a2ab05604515887
 SHA512:
-  metadata.gz: 3b083816314fdf992eaca0cb0216795e2c7a6c1cc7e2f32669452201c45b29d6254dcbc2f69a665d6a0852242423bd87cdf62a88feda5f463e6f774b142d0520
-  data.tar.gz: 8a94b4b649cfd45fa1143e6866d119811236771980f508d0643b0b51b1d6bbdb2e241233a469086a0b5a3e22529c08d1c23b7825966fe78e367defd4672d20c2
+  metadata.gz: de05664b8aa2a23c158815c73159fe3466aef2f17697093558407b022becf095b737e05bd23e20bfb3ed1923b41405297b9658f91a6ecb1ae1f943e5022bcebd
+  data.tar.gz: 2ec30ad8a9e1a3ebc7ea16080729684117d38033109b7e829a959e11802b909fd14202fd85d248f38f0770b083e5b8b95e25f9a83d8659487d80598ed5c5795b

data/README.md

@@ -30,22 +30,6 @@ This can be done by specifying tags such as scalyr.apache, scalyr.maillog etc an
 
 Fluentd tag names will be used for the logfile name in Scalyr.
 
-Scalyr Parsers and Custom Fields
---------------------------------
-
-You may also need to specify a Scalyr parser for your log message or add custom fields to each log event. This can be done using Fluentd's filter mechanism, in particular the [record_transformer filter](https://docs.fluentd.org/filter/record_transformer).
-
-For example, if you want to use Scalyr's ```accessLog``` parser for all events with the ```scalyr.access``` tag you would add the following to your fluent.conf file:
-
-```
-<filter scalyr.access>
-  @type record_transformer
-  <record>
-    parser accessLog
-  </record>
-</filter>
-```
-
 Plugin Configuration
 -------------
 
@@ -80,6 +64,7 @@ The following configuration options are also supported:
   ssl_verify_peer true
   ssl_verify_depth 5
   message_field message
+  parser nil
 
   max_request_buffer 5500000
 
@@ -104,6 +89,32 @@ For some additional examples of configuration for different setups, please refer
 [examples/configs/](https://github.com/scalyr/scalyr-fluentd/tree/master/examples/configs/)
 directory.
 
+Scalyr Parsers and Custom Fields
+--------------------------------
+
+You may also need to specify a Scalyr parser for your log message or add custom fields to each log event. This can be done using Fluentd's filter mechanism, in particular the [record_transformer filter](https://docs.fluentd.org/filter/record_transformer).
+
+For example, if you want to use Scalyr's ```accessLog``` parser for all events with the ```scalyr.access``` tag you would add the following to your fluent.conf file:
+
+```
+<filter scalyr.access>
+  @type record_transformer
+  <record>
+    parser accessLog
+  </record>
+</filter>
+```
+
+Alternatively, if the same parser can be used for all events sent by the Fluentd output plugin, the parser can be set using the ```parser``` plugin configuration. For example, to use Scalyr's ```accessLog``` parser for all events, use the output plugin configuration:
+
+```
+<match scalyr.*>
+  @type scalyr
+  api_write_token YOUR_SCALYR_WRITE_LOGS_TOKEN
+  parser accessLog
+</match>
+```
+
 ### Scalyr specific options
 
 ***compression_type*** - compress Scalyr traffic to reduce network traffic. Options are `bz2` and `deflate`. See [here](https://www.scalyr.com/help/scalyr-agent#compressing) for more details.  This feature is optional.
@@ -134,6 +145,8 @@ The cURL project maintains CA certificate bundles automatically converted from m
 
 ***message_field*** - Scalyr expects all log events to have a 'message' field containing the contents of a log message.  If your event has the log message stored in another field, you can specify the field name here, and the plugin will rename that field to 'message' before sending the data to Scalyr.  **Note:** this will override any existing 'message' field if the log record contains both a 'message' field and the field specified by this config option.
 
+***parser*** - The Scalyr parser to use to parse the 'message' field for each event. This value is optional and defaults to *nil*.
+
 ***max_request_buffer*** - The maximum size in bytes of each request to send to Scalyr.  Defaults to 5,500,000 (5.5MB).  Fluentd chunks that generate JSON requests larger than the max_request_buffer will be split in to multiple separate requests.  **Note:** The maximum size the Scalyr servers accept for this value is 6MB and requests containing data larger than this will be rejected.
 
 ***force_message_encoding*** - Set a specific encoding for all your log messages (defaults to nil).  If your log messages are not in UTF-8, this can cause problems when converting the message to JSON in order to send to the Scalyr server.  You can avoid these problems by setting an encoding for your log messages so they can be correctly converted.

data/Rakefile

@@ -9,6 +9,7 @@ Rake::TestTask.new(:test) do |test|
   test.libs << "lib" << "test"
   test.test_files = FileList["test/test_*.rb"]
   test.verbose = true
+  test.options = "--verbose=verbose"
 end
 
 task default: [:build]

data/VERSION

@@ -1 +1 @@
-0.8.11
+0.8.16

data/lib/fluent/plugin/out_scalyr.rb

@@ -19,6 +19,7 @@
 
 require "fluent/plugin/output"
 require "fluent/plugin/scalyr_exceptions"
+require "fluent/plugin/scalyr_utils"
 require "fluent/plugin_helper/compat_parameters"
 require "json"
 require "net/http"
@@ -36,6 +37,7 @@ module Scalyr
 
     config_param :api_write_token, :string
     config_param :server_attributes, :hash, default: nil
+    config_param :parser, :string, default: nil # Set the "parser" field to this, per event.
     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
@@ -71,6 +73,12 @@ module Scalyr
     end
 
     def configure(conf)
+      @version = if Gem.loaded_specs.key?("fluent-plugin-scalyr")
+                   Gem.loaded_specs["fluent-plugin-scalyr"].version
+                 else
+                   "unknown"
+                 end
+
       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
@@ -144,7 +152,7 @@ module 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=#{plugin_id} worker=#{fluentd_worker_id} session=#{@session}" # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
+      $log.info "Scalyr Fluentd Plugin ID id=#{plugin_id} worker=#{fluentd_worker_id} session=#{@session} version=#{@version}" # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
     end
 
     def format(tag, time, record)
@@ -252,8 +260,8 @@ module Scalyr
 
       post = Net::HTTP::Post.new uri.path
       post.add_field("Content-Type", "application/json")
-
       post.add_field("Content-Encoding", encoding) if @compression_type
+      post.add_field("User-Agent", "fluent-plugin-scalyr;#{@version}")
 
       post.body = body
 
@@ -321,6 +329,9 @@ module Scalyr
         # add a logfile field if one doesn't exist
         record["logfile"] = "/fluentd/#{tag}" unless record.key? "logfile"
 
+        # set per-event parser if it is configured
+        record["parser"] = @parser unless @parser.nil?
+
         # append to list of events
         event = {thread: thread_id.to_s,
                  ts:     timestamp,
@@ -331,29 +342,59 @@ module Scalyr
         begin
           event_json = event.to_json
         rescue JSON::GeneratorError, Encoding::UndefinedConversionError => e
-          $log.warn "#{e.class}: #{e.message}"
+          $log.warn "JSON serialization of the event failed: #{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)
           router.emit_error_event(tag, time, record, e)
 
+          # Print attribute values for debugging / troubleshooting purposes
+          $log.debug "Event attributes:"
+
           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") # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
+            # NOTE: value doesn't always value.encoding attribute so we use .class which is always available
+            $log.debug "\t#{key} (#{value.class}): '#{value}'"
           end
+
+          # Recursively re-encode and sanitize potentially bad string values
+          event[:attrs] = sanitize_and_reencode_value(event[:attrs])
           event_json = event.to_json
         end
 
         # 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
+          # the case where a single event causes us to exceed the @max_request_buffer
           if events.empty?
-            events << event
+            # if we are able to truncate the content (and append an ellipsis)
+            # inside the @message_field we do so here
+            if record.key?(@message_field) &&
+              record[@message_field].is_a?(String) &&
+              record[@message_field].bytesize > event_json.bytesize - @max_request_buffer &&
+              record[@message_field].bytesize >= 3
+
+              @log.warn "Received a record that cannot fit within max_request_buffer "\
+                "(#{@max_request_buffer}) from #{record['logfile']}, serialized event size "\
+                "is #{event_json.bytesize}. The #{@message_field} field will be truncated to fit."
+              max_msg_size = @max_request_buffer - event_json.bytesize - 3
+              truncated_msg = event[:attrs][@message_field][0...max_msg_size] + "..."
+              event[:attrs][@message_field] = truncated_msg
+              events << event
+
+            # otherwise we drop the event and save ourselves hitting a 4XX response from the server
+            else
+              @log.warn "Received a record that cannot fit within max_request_buffer "\
+                "(#{@max_request_buffer}) from #{record['logfile']}, serialized event size "\
+                "is #{event_json.bytesize}. The #{@message_field} field too short to truncate, "\
+                "dropping event."
+            end
             append_event = false
           end
-          request = create_request(events, current_threads)
-          requests << request
+
+          unless events.empty?
+            request = create_request(events, current_threads)
+            requests << request
+          end
 
           total_bytes = 0
           current_threads = {}
@@ -369,8 +410,12 @@ module Scalyr
       }
 
       # create a final request with any left over events
-      request = create_request(events, current_threads)
-      requests << request
+      unless events.empty?
+        request = create_request(events, current_threads)
+        requests << request
+      end
+
+      requests
     end
 
     def create_request(events, current_threads)

data/lib/fluent/plugin/scalyr_utils.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+#
+# Scalyr Output Plugin for Fluentd
+#
+# Copyright (C) 2020 Scalyr, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Scalyr
+  def sanitize_and_reencode_value(value)
+    # Method which recursively sanitizes the provided value and tries to re-encode all the strings as
+    # UTF-8 ignoring any bad unicode sequences
+    case value
+    when Hash
+      return sanitize_and_reencode_hash(value)
+    when Array
+      return sanitize_and_reencode_array(value)
+    when String
+      value = sanitize_and_reencode_string(value)
+      return value
+    end
+
+    # We only need to re-encode strings, for other value types (ints, nils,
+    # etc. no reencoding is needed)
+    value
+  end
+
+  def sanitize_and_reencode_array(array)
+    array.each_with_index do |value, index|
+      value = sanitize_and_reencode_value(value)
+      array[index] = value
+    end
+
+    array
+  end
+
+  def sanitize_and_reencode_hash(hash)
+    hash.each do |key, value|
+      hash[key] = sanitize_and_reencode_value(value)
+    end
+
+    hash
+  end
+
+  def sanitize_and_reencode_string(value)
+    # Function which sanitized the provided string value and tries to re-encode it as UTF-8
+    # ignoring any encoding error which could arise due to bad or partial unicode sequence
+    begin # rubocop:disable Style/RedundantBegin
+      value.encode("UTF-8", invalid: :replace, undef: :replace, replace: "<?>").force_encoding("UTF-8") # rubocop:disable Layout/LineLength, Lint/RedundantCopDisableDirective
+    rescue # rubocop:disable Style/RescueStandardError
+      "failed-to-reencode-as-utf8"
+    end
+  end
+end

data/test/test_config.rb

@@ -57,5 +57,10 @@ class ConfigTest < Scalyr::ScalyrOutTest
     d = create_driver CONFIG + 'server_attributes { "test":"value" }'
     assert_equal("value", d.instance.server_attributes["test"], "Config failed to set server_attributes")
   end
+
+  def test_configure_parser
+    d = create_driver CONFIG + "parser access_log"
+    assert_equal("access_log", d.instance.parser, "Config failed to set parser")
+  end
 end
 # rubocop:enable Layout/LineLength

data/test/test_events.rb

@@ -136,6 +136,34 @@ class EventsTest < Scalyr::ScalyrOutTest
     assert_equal(mock_called, true, "mock method was never called!")
   end
 
+  def test_build_add_events_body_with_parser
+    d = create_driver CONFIG + "parser test_parser"
+
+    time = event_time("2015-04-01 10:00:00 UTC")
+    attrs = {"a" => 1}
+
+    response = flexmock(Net::HTTPResponse, code: "200", body: '{ "status":"success" }')
+    mock = flexmock(d.instance)
+
+    mock_called = false
+
+    mock.should_receive(:post_request).with(
+      URI,
+      on {|request_body|
+        body = JSON.parse(request_body)
+        assert_equal("test_parser", body["events"][0]["attrs"]["parser"])
+        mock_called = true
+        true
+      }
+    ).once.and_return(response)
+
+    d.run(default_tag: "test") do
+      d.feed(time, attrs)
+    end
+
+    assert_equal(mock_called, true, "mock method was never called!")
+  end
+
   def test_build_add_events_body_incrementing_timestamps
     d = create_driver
 
@@ -170,6 +198,88 @@ class EventsTest < Scalyr::ScalyrOutTest
     assert_equal(mock_called, true, "mock method was never called!")
   end
 
+  def test_build_add_events_body_non_json_serializable_value
+    d = create_driver
+
+    time = event_time("2015-04-01 10:00:00 UTC")
+    attrs = {"a" => 1}
+    attrs["int1"] = 1_601_923_119
+    attrs["int2"] = Integer(1_601_923_119)
+    attrs["int3"] = Integer(9_223_372_036_854_775_807)
+    attrs["int4"] = Integer(-1)
+    attrs["nil"] = nil
+    attrs["array"] = [1, 2, "a", "b", nil]
+    attrs["hash"] = {
+      "a" => "1",
+      "b" => "c"
+    }
+    attrs["logfile"] = "/some/log/file"
+
+    # This partial unicode sequence will fail encoding so we make sure it doesn't break the plugin
+    # and we correctly cast it to a value which we can send to the API
+    attrs["partial_unicode_sequence"] = "\xC2"
+    attrs["array_with_partial_unicode_sequence"] = [1, 2, "a", "b", nil, "7", "\xC2"]
+    attrs["nested_array_with_partial_unicode_sequence"] = [1, 2, "a", "b", nil, "7",
+                                                           [8, 9, [10, "\xC2"]],
+                                                           {"a" => 1, "b" => "\xC2"}]
+    attrs["hash_with_partial_unicode_sequence"] = {
+      "a" => "1",
+      "b" => "\xC2",
+      "c" => nil
+    }
+    attrs["nested_hash_with_partial_unicode_sequence"] = {
+      "a" => "1",
+      "b" => {
+        "c" => "\xC2",
+        "d" => "e",
+        "f" => nil,
+        "g" => {
+          "h" => "\xC2",
+          "b" => 3
+        }
+      }
+    }
+
+    response = flexmock(Net::HTTPResponse, code: "200", body: '{ "status":"success" }')
+    mock = flexmock(d.instance)
+
+    mock_called = false
+
+    # NOTE: We need to perform a deep clone / copy
+    expected_attrs = Marshal.load(Marshal.dump(attrs))
+
+    expected_attrs["partial_unicode_sequence"] = "<?>"
+    expected_attrs["array_with_partial_unicode_sequence"][-1] = "<?>"
+    expected_attrs["nested_array_with_partial_unicode_sequence"][-2][-1][-1] = "<?>"
+    expected_attrs["nested_array_with_partial_unicode_sequence"][-1]["b"] = "<?>"
+    expected_attrs["hash_with_partial_unicode_sequence"]["b"] = "<?>"
+    expected_attrs["nested_hash_with_partial_unicode_sequence"]["b"]["c"] = "<?>"
+    expected_attrs["nested_hash_with_partial_unicode_sequence"]["b"]["g"]["h"] = "<?>"
+
+    # Verify that clone / copy was correct and the original object wasn't modified
+    assert_not_equal(expected_attrs, attrs, "Objects are the same but should be different")
+    assert_not_equal(Marshal.load(Marshal.dump(attrs)), Marshal.load(Marshal.dump(expected_attrs)))
+    assert_equal(attrs["partial_unicode_sequence"], "\xC2")
+    assert_equal(attrs["array_with_partial_unicode_sequence"][-1], "\xC2")
+    assert_equal(attrs["nested_hash_with_partial_unicode_sequence"]["b"]["g"]["h"], "\xC2")
+
+    mock.should_receive(:post_request).with(
+      URI,
+      on {|request_body|
+        body = JSON.parse(request_body)
+        assert_equal(expected_attrs, body["events"][0]["attrs"], "Value of attrs differs from log")
+        mock_called = true
+        true
+      }
+    ).once.and_return(response)
+
+    d.run(default_tag: "test") do
+      d.feed(time, attrs)
+    end
+
+    assert_equal(mock_called, true, "mock method was never called!")
+  end
+
   def test_default_message_field
     d = create_driver CONFIG
 
@@ -247,4 +357,48 @@ class EventsTest < Scalyr::ScalyrOutTest
       d.feed(time, attrs)
     end
   end
+
+  def test_truncated_large_event
+    d = create_driver CONFIG + "max_request_buffer 4000"
+
+    time = event_time("2015-04-01 10:00:00 UTC")
+    attrs = {"log" => "this is a test", "message" => "0123456789" * 500}
+
+    response = flexmock(Net::HTTPResponse, code: "200", body: '{ "status":"success" }')
+    mock = flexmock(d.instance)
+
+    mock.should_receive(:post_request).with(
+      URI,
+      on {|request_body|
+        body = JSON.parse(request_body)
+        events = body["events"]
+        assert(events[0]["attrs"].key?("message"), "'message' field not found in event")
+        assert_equal(
+          "0123456789" * 388 + "012...",
+          events[0]["attrs"]["message"],
+          "'message' field incorrect"
+        )
+        true
+      }
+    ).once.and_return(response)
+
+    d.run(default_tag: "test") do
+      d.feed(time, attrs)
+    end
+  end
+
+  def test_dropped_large_event
+    d = create_driver CONFIG + "max_request_buffer 4000"
+
+    time = event_time("2015-04-01 10:00:00 UTC")
+    attrs = {"message" => "this is a test", "not_message" => "0123456789" * 500}
+
+    mock = flexmock(d.instance)
+
+    mock.should_receive(:post_request).never
+
+    d.run(default_tag: "test") do
+      d.feed(time, attrs)
+    end
+  end
 end

data/test/test_utils.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+#
+# Scalyr Output Plugin for Fluentd
+#
+# Copyright (C) 2015 Scalyr, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "helper"
+require "flexmock/test_unit"
+
+require "fluent/plugin/scalyr_utils"
+include Scalyr # rubocop:disable Style/MixinUsage
+
+module Scalyr
+  class UtilsTest < Test::Unit::TestCase
+    def test_sanitize_and_reencode_value_simple_types
+      # Simple value - string
+      result = sanitize_and_reencode_value("test foo")
+      assert_equal("test foo", result)
+
+      # Simple value - string with bad unicode sequences
+      result = sanitize_and_reencode_value("test \xC2 foo \xC2 bar")
+      assert_equal("test <?> foo <?> bar", result)
+
+      # Simple value - int
+      result = sanitize_and_reencode_value(100)
+      assert_equal(100, result)
+
+      # Simple value - nill
+      result = sanitize_and_reencode_value(nil)
+      assert_equal(nil, result)
+
+      # Simple value - bool
+      result = sanitize_and_reencode_value(true)
+      assert_equal(true, result)
+
+      result = sanitize_and_reencode_value(false)
+      assert_equal(false, result)
+    end
+
+    def test_sanitize_and_reencode_value_complex_nested_types
+      actual = [1, 2, "a", "b", nil, "7", "\xC2"]
+      expected = [1, 2, "a", "b", nil, "7", "<?>"]
+
+      result = sanitize_and_reencode_value(actual)
+      assert_equal(expected, result)
+
+      actual = [1, 2, "a", "b", nil, "7",
+                [8, 9, [10, "\xC2"]],
+                {"a" => 1, "b" => "\xC2"}]
+      expected = [1, 2, "a", "b", nil, "7",
+                  [8, 9, [10, "<?>"]],
+                  {"a" => 1, "b" => "<?>"}]
+
+      result = sanitize_and_reencode_value(actual)
+      assert_equal(expected, result)
+
+      actual = {
+        "a" => "1",
+        "b" => {
+          "c" => "\xC2",
+          "d" => "e",
+          "f" => nil,
+          "g" => {
+            "h" => "bar \xC2",
+            "b" => 3,
+            "l" => [1, 2, "foo\xC2", 3, 4, 5]
+          }
+        }
+      }
+      expected = {
+        "a" => "1",
+        "b" => {
+          "c" => "<?>",
+          "d" => "e",
+          "f" => nil,
+          "g" => {
+            "h" => "bar <?>",
+            "b" => 3,
+            "l" => [1, 2, "foo<?>", 3, 4, 5]
+          }
+        }
+      }
+      result = sanitize_and_reencode_value(actual)
+      assert_equal(expected, result)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-scalyr
 version: !ruby/object:Gem::Version
-  version: 0.8.11
+  version: 0.8.16
 platform: ruby
 authors:
 - Imron Alston
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-19 00:00:00.000000000 Z
+date: 2022-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -158,11 +158,13 @@ files:
 - fluent.conf.sample
 - lib/fluent/plugin/out_scalyr.rb
 - lib/fluent/plugin/scalyr_exceptions.rb
+- lib/fluent/plugin/scalyr_utils.rb
 - test/helper.rb
 - test/test_config.rb
 - test/test_events.rb
 - test/test_handle_response.rb
 - test/test_ssl_verify.rb
+- test/test_utils.rb
 homepage: https://github.com/scalyr/scalyr-fluentd
 licenses:
 - Apache-2.0
@@ -188,7 +190,8 @@ specification_version: 4
 summary: Scalyr plugin for fluentd
 test_files:
 - test/helper.rb
+- test/test_config.rb
 - test/test_events.rb
 - test/test_handle_response.rb
-- test/test_config.rb
 - test/test_ssl_verify.rb
+- test/test_utils.rb