logstash-output-scalyr 0.2.7.beta → 0.2.8.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '098686f8c748dbe1d02cec87e92aa49df5db05049ff0d87ccd6fbb6271ccd797'
-  data.tar.gz: '0073297594f936703190252584559ae60cd81a7b3807f1b2685b6966fece5610'
+  metadata.gz: da91d80d418081307dc1a6b756f17024712c0eab9a6d527a140288976a58b76f
+  data.tar.gz: 2ac792b42939edb371614c73c4dbb50fcc835f199d03685ff619d9d355c6465a
 SHA512:
-  metadata.gz: 507ddc7c825ae4612907c4ad451597bf516732b389b5a628598f8eec12e8cdc1f7c4b5b71533803665d1fd18b3fce43a0aa3989729192eea26b2948273f9d267
-  data.tar.gz: 310a452e0df0b74081a061030322b3f2a013bad233ba99b424fcea428af336f86370cb76bda62c06c5edcbee81731e5a498e137daf4f7d42a843ef988a8664df
+  metadata.gz: 0a87ca7115a2eb3f03282046510bd51869e575eb29b8bec6ee273cbc9f68fea0167890835ffdda8bd0d571ac4299aff689642542d8dd5d88eaa2a89fe760a3f0
+  data.tar.gz: 7457fff5003d10b7288a9a958f3ec3f4a490c19da51a3ac3ade0402a37f74fafffc2501185857b4b3a7263753cb6af3276471724870efa0dca9e0773671b2f3f

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Beta
 
+## 0.2.8.beta
+
+* Update ``.gemspec`` gem metadata to not include ``spec/`` directory with the tests and tests
+  fixtures with the actual production gem file.
+
+* Do not retry requests that will never be accepted by the server.
+  Specifically, any request that returns HTTP Status code 413 is too large, and
+  will never be accepted. Instead of simply retrying for 10 minutes before
+  sending the request to the DLQ, skip the retries go directly to sending the
+  request to the DLQ.
+
+  To be notified when an event fails to be ingested for whatever reason, create
+  an alert using the query: ``parser='logstash_plugin_metrics'
+  failed_events_processed > 0``. Instructions on how to create an alert can be
+  found in our docs here: https://scalyr.com/help/alerts
+
 ## 0.2.7.beta
 
 * SSL cert validation code has been simplified. Now ``ssl_ca_bundle_path`` config option

data/README.md

@@ -505,10 +505,9 @@ To deploy the current code on your machine run these commands:
 
 ```
 rm -rf vendor/
-bundle check --path vendor/bundle || bundle install --deployment
+bundle install
 curl -u RUBY_USER:RUBY_PASSWORD https://rubygems.org/api/v1/api_key.yaml > ~/.gem/credentials
 chmod 0600 ~/.gem/credentials
-bundle exec rake vendor
 bundle exec rspec
 bundle exec rake publish_gem
 ```
@@ -518,10 +517,9 @@ Or as an alternative if ``rake publish_gem`` task doesn't appear to work for wha
 
 ```
 rm -rf vendor/
-bundle check --path vendor/bundle || bundle install --deployment
+bundle install
 curl -u RUBY_USER:RUBY_PASSWORD https://rubygems.org/api/v1/api_key.yaml > ~/.gem/credentials
 chmod 0600 ~/.gem/credentials
-bundle exec rake vendor
 bundle exec rspec
 rvm use jruby
 bundle exec gem build logstash-output-scalyr.gemspec

data/lib/logstash/outputs/scalyr.rb

@@ -500,6 +500,24 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
             result.push(multi_event_request)
           end
 
+        rescue Scalyr::Common::Client::PayloadTooLargeError => e
+          # if the payload is too large, we do not retry. we send to DLQ or drop it.
+          exc_data = {
+              :error_class => e.e_class,
+              :url => e.url.to_s,
+              :message => e.message,
+              :batch_num => batch_num,
+              :total_batches => total_batches,
+              :record_count => multi_event_request[:record_count],
+              :payload_size => multi_event_request[:body].bytesize,
+          }
+          exc_data[:code] = e.code if e.code
+          if defined?(e.body) and e.body
+            exc_data[:body] = Scalyr::Common::Util.truncate(e.body, 512)
+          end
+          exc_data[:payload] = "\tSample payload: #{multi_event_request[:body][0,1024]}..."
+          log_retry_failure(multi_event_request, exc_data, 0, 0)
+          next
         rescue Scalyr::Common::Client::ServerError, Scalyr::Common::Client::ClientError => e
           sleep_interval = sleep_for(sleep_interval)
           exc_sleep += sleep_interval
@@ -634,18 +652,25 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
       @multi_receive_statistics[:total_events_processed] += multi_event_request[:logstash_events].length
       @multi_receive_statistics[:failed_events_processed] += multi_event_request[:logstash_events].length
     end
-    message = "Failed to send #{multi_event_request[:logstash_events].length} events after #{exc_retries} tries."
     sample_events = Array.new
     multi_event_request[:logstash_events][0,5].each {|l_event|
       sample_events << Scalyr::Common::Util.truncate(l_event.to_hash.to_json, 256)
     }
-    @logger.error(message, :error_data => exc_data, :sample_events => sample_events, :retries => exc_retries, :sleep_time => exc_sleep)
+    if exc_data[:code] == 413
+      message = "Failed to send #{multi_event_request[:logstash_events].length} events due to exceeding maximum request size. Not retrying non-retriable request."
+      # For PayloadTooLargeError we already include sample Scalyr payload in exc_data so there is no need
+      # to include redundant sample Logstash event objects
+      @logger.error(message, :error_data => exc_data)
+    else
+      message = "Failed to send #{multi_event_request[:logstash_events].length} events after #{exc_retries} tries."
+      @logger.error(message, :error_data => exc_data, :sample_events => sample_events, :retries => exc_retries, :sleep_time => exc_sleep)
+    end
     if @dlq_writer
       multi_event_request[:logstash_events].each {|l_event|
         @dlq_writer.write(l_event, "#{exc_data[:message]}")
       }
     else
-      @logger.warn("Dead letter queue not configured, dropping #{multi_event_request[:logstash_events].length} events after #{exc_retries} tries.", :sample_events => sample_events)
+      @logger.warn("Dead letter queue not configured, dropping #{multi_event_request[:logstash_events].length} events.", :sample_events => sample_events)
     end
   end
 
@@ -1050,7 +1075,7 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
     serialized_request_size = serialized_body.bytesize
 
     # We give it "buffer" since the splitting code allows for some slack and doesn't take into account top-level non-event attributes
-    if not @estimate_each_event_size and serialized_request_size >= @max_request_buffer + 5000
+    if serialized_request_size >= @max_request_buffer + 5000
       # TODO: If we end up here is estimate config opsion is false, split the request here into multiple ones
       @logger.warn("Serialized request size (#{serialized_request_size}) is larger than max_request_buffer (#{max_request_buffer})!")
     end

data/lib/scalyr/common/client.rb

@@ -27,6 +27,18 @@ end
 # An exception that signifies the Scalyr server received the upload request but dropped it
 #---------------------------------------------------------------------------------------------------------------------
 class RequestDroppedError < ServerError;
+  def initialize(msg=nil, code=nil, url=nil, body=nil, e_class="Scalyr::Common::Client::RequestDroppedError")
+    super(msg, code, url, body, e_class)
+  end
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# An exception that signifies the Scalyr server received the upload request but dropped it due to it being too large.
+#---------------------------------------------------------------------------------------------------------------------
+class PayloadTooLargeError < ServerError;
+  def initialize(msg=nil, code=nil, url=nil, body=nil, e_class="Scalyr::Common::Client::PayloadTooLargeError")
+    super(msg, code, url, body, e_class)
+  end
 end
 
 #---------------------------------------------------------------------------------------------------------------------
@@ -308,15 +320,17 @@ class ClientSession
     end
 
     status = response_hash["status"]
+    code = response.code.to_s.strip.to_i
 
     if status != "success"
-      if status =~ /discardBuffer/
+      if code == 413
+        raise PayloadTooLargeError.new(status, response.code, @add_events_uri, response.body)
+      elsif status =~ /discardBuffer/
         raise RequestDroppedError.new(status, response.code, @add_events_uri, response.body)
       else
         raise ServerError.new(status, response.code, @add_events_uri, response.body)
       end
     else
-      code = response.code.to_s.strip.to_i
       if code < 200 or code > 299
         raise ServerError.new(status, response.code, @add_events_uri, response.body)
       end

data/lib/scalyr/constants.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-PLUGIN_VERSION = "v0.2.7.beta"
+PLUGIN_VERSION = "v0.2.8.beta"
 
 # Special event level attribute name which can be used for setting event level serverHost attribute
 EVENT_LEVEL_SERVER_HOST_ATTRIBUTE_NAME = '__origServerHost'

data/logstash-output-scalyr.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'logstash-output-scalyr'
-  s.version         = '0.2.7.beta'
+  s.version         = '0.2.8.beta'
   s.licenses = ['Apache-2.0']
   s.summary = "Scalyr output plugin for Logstash"
   s.description     = "Sends log data collected by Logstash to Scalyr (https://www.scalyr.com)"
@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # Files
-  s.files = Dir['lib/**/*','spec/**/*','*.gemspec','*.md','CONTRIBUTORS','Gemfile','LICENSE','NOTICE.TXT']
+  s.files = Dir['lib/**/*','*.gemspec','*.md','CONTRIBUTORS','Gemfile','LICENSE','NOTICE.TXT']
   # Tests
   s.test_files = s.files.grep(%r{^(test|spec|features)/})
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-scalyr
 version: !ruby/object:Gem::Version
-  version: 0.2.7.beta
+  version: 0.2.8.beta
 platform: ruby
 authors:
 - Edward Chee
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-04 00:00:00.000000000 Z
+date: 2022-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -165,16 +165,6 @@ files:
 - lib/scalyr/common/util.rb
 - lib/scalyr/constants.rb
 - logstash-output-scalyr.gemspec
-- spec/benchmarks/bignum_fixing.rb
-- spec/benchmarks/flattening_and_serialization.rb
-- spec/benchmarks/json_serialization.rb
-- spec/benchmarks/metrics_overhead.rb
-- spec/benchmarks/set_session_level_serverhost_on_events.rb
-- spec/benchmarks/util.rb
-- spec/logstash/outputs/fixtures/example_com.pem
-- spec/logstash/outputs/scalyr_integration_spec.rb
-- spec/logstash/outputs/scalyr_spec.rb
-- spec/scalyr/common/util_spec.rb
 homepage: https://www.scalyr.com/help/data-sources#logstash
 licenses:
 - Apache-2.0
@@ -201,14 +191,4 @@ rubygems_version: 2.7.10
 signing_key:
 specification_version: 4
 summary: Scalyr output plugin for Logstash
-test_files:
-- spec/benchmarks/bignum_fixing.rb
-- spec/benchmarks/flattening_and_serialization.rb
-- spec/benchmarks/json_serialization.rb
-- spec/benchmarks/metrics_overhead.rb
-- spec/benchmarks/set_session_level_serverhost_on_events.rb
-- spec/benchmarks/util.rb
-- spec/logstash/outputs/fixtures/example_com.pem
-- spec/logstash/outputs/scalyr_integration_spec.rb
-- spec/logstash/outputs/scalyr_spec.rb
-- spec/scalyr/common/util_spec.rb
+test_files: []

data/spec/benchmarks/bignum_fixing.rb

@@ -1,87 +0,0 @@
-require 'benchmark'
-require 'quantile'
-
-require_relative '../../lib/scalyr/common/util'
-require_relative './util'
-
-# Micro benchmark which measures how long it takes to find all the Bignums in a record and convert them to strings
-
-ITERATIONS = 500
-
-def rand_bignum()
-  return 200004000020304050300 + rand(999999)
-end
-
-def generate_hash(widths)
-  result = {}
-  if widths.empty?
-    return rand_bignum()
-  else
-    widths[0].times do
-      result[rand_str(9)] = generate_hash(widths[1..widths.length])
-    end
-    return result
-  end
-end
-
-def generate_data_array_for_spec(spec)
-  data = []
-  ITERATIONS.times do
-    data << generate_hash(spec)
-  end
-
-  data
-end
-
-def run_benchmark_and_print_results(data, run_benchmark_func)
-  puts ""
-  puts "Using %s total keys in a hash" % [Scalyr::Common::Util.flatten(data[0]).count]
-  puts ""
-
-  result = []
-  ITERATIONS.times do |i|
-    result << Benchmark.measure { run_benchmark_func.(data[i]) }
-  end
-
-  sum = result.inject(nil) { |sum, t| sum.nil? ? sum = t : sum += t }
-  avg = sum / result.size
-
-  Benchmark.bm(7, "sum:", "avg:") do |b|
-    [sum, avg]
-  end
-  puts ""
-end
-
-
-puts "Using %s iterations" % [ITERATIONS]
-puts ""
-
-@value = Quantile::Estimator.new
-@prng = Random.new
-
-def convert_bignums(record)
-  Scalyr::Common::Util.convert_bignums(record)
-end
-
-puts "Util.convert_bignums()"
-puts "==============================="
-
-# Around ~200 keys in a hash
-data = generate_data_array_for_spec([4, 4, 3, 4])
-run_benchmark_and_print_results(data, method(:convert_bignums))
-
-# Around ~200 keys in a hash (single level)
-data = generate_data_array_for_spec([200])
-run_benchmark_and_print_results(data, method(:convert_bignums))
-
-# Around ~512 keys in a hash
-data = generate_data_array_for_spec([8, 4, 4, 4])
-run_benchmark_and_print_results(data, method(:convert_bignums))
-
-# Around ~960 keys in a hash
-data = generate_data_array_for_spec([12, 5, 4, 4])
-run_benchmark_and_print_results(data, method(:convert_bignums))
-
-# Around ~2700 keys in a hash
-data = generate_data_array_for_spec([14, 8, 6, 4])
-run_benchmark_and_print_results(data, method(:convert_bignums))

data/spec/benchmarks/flattening_and_serialization.rb

@@ -1,100 +0,0 @@
-require 'benchmark'
-require 'json'
-
-require_relative '../../lib/scalyr/common/util'
-require_relative './util'
-
-# NOTE: When using jRuby using multiple iterations with the same dataset doesn't make
-# sense since it will just use JITed version of the code which will be very fast. If we
-# wanted to accurately measure using multiple iterations we would need te different
-# input data for each iteration.
-ITERATIONS = 500
-
-def run_benchmark_and_print_results(data, run_benchmark_func)
-  puts ""
-  puts "Using %s total keys in a hash" % [Scalyr::Common::Util.flatten(data[0]).count]
-  puts ""
-
-  result = []
-  ITERATIONS.times do |i|
-    result << Benchmark.measure { run_benchmark_func.(data[i]) }
-  end
-
-  sum = result.inject(nil) { |sum, t| sum.nil? ? sum = t : sum += t }
-  avg = sum / result.size
-
-  Benchmark.bm(7, "sum:", "avg:") do |b|
-    [sum, avg]
-  end
-  puts ""
-end
-
-def flatten_data_func(data)
-  Scalyr::Common::Util.flatten(data)
-end
-
-def json_serialize_data(data)
-  data.to_json
-end
-
-DATASETS = {
-  :keys_50 => generate_data_array_for_spec([3, 3, 3, 2]),
-  :keys_200 => generate_data_array_for_spec([4, 4, 3, 4]),
-  :keys_200_flat => generate_data_array_for_spec([200]),
-  :keys_512 => generate_data_array_for_spec([8, 4, 4, 4]),
-  :keys_960 => generate_data_array_for_spec([12, 5, 4, 4]),
-  :keys_2700 => generate_data_array_for_spec([14, 8, 6, 4])
-}
-
-puts "Using %s iterations" % [ITERATIONS]
-puts ""
-
-puts "Scalyr::Common::Util.flatten()"
-puts "==============================="
-
-# Around ~50 keys in a hash
-data = DATASETS[:keys_50]
-run_benchmark_and_print_results(data, method(:flatten_data_func))
-
-# Around ~200 keys in a hash
-data = DATASETS[:keys_200]
-run_benchmark_and_print_results(data, method(:flatten_data_func))
-
-# Around ~200 keys in a hash (single level)
-data = DATASETS[:keys_200_flat]
-run_benchmark_and_print_results(data, method(:flatten_data_func))
-
-# Around ~512 keys in a hash
-data = DATASETS[:keys_512]
-run_benchmark_and_print_results(data, method(:flatten_data_func))
-
-# Around ~960 keys in a hash
-data = DATASETS[:keys_960]
-run_benchmark_and_print_results(data, method(:flatten_data_func))
-
-# Around ~2700 keys in a hash
-data = DATASETS[:keys_2700]
-run_benchmark_and_print_results(data, method(:flatten_data_func))
-
-puts "JSON.dumps (hash.to_dict)"
-puts "==============================="
-
-# Around ~200 keys in a hash
-data = generate_data_array_for_spec([4, 4, 3, 4])
-run_benchmark_and_print_results(data, method(:json_serialize_data))
-
-# Around ~200 keys in a hash (single level)
-data = DATASETS[:keys_200_flat]
-run_benchmark_and_print_results(data, method(:json_serialize_data))
-
-# Around ~512 keys in a hash
-data = generate_data_array_for_spec([8, 4, 4, 4])
-run_benchmark_and_print_results(data, method(:json_serialize_data))
-
-# Around ~960 keys in a hash
-data = generate_data_array_for_spec([12, 5, 4, 4])
-run_benchmark_and_print_results(data, method(:json_serialize_data))
-
-# Around ~2700 keys in a hash
-data = generate_data_array_for_spec([14, 8, 6, 4])
-run_benchmark_and_print_results(data, method(:json_serialize_data))

data/spec/benchmarks/json_serialization.rb

@@ -1,85 +0,0 @@
-require 'benchmark'
-require 'json'
-require 'jrjackson'
-
-require_relative '../../lib/scalyr/common/util'
-require_relative './util'
-
-ITERATIONS = 500
-
-def json_serialize_data_native(data)
-  data.to_json
-end
-
-def json_serialize_data_jrjackson(data)
-  JrJackson::Json.dump(data)
-end
-
-DATASETS = {
-  :keys_50 => generate_data_array_for_spec([3, 3, 3, 2]),
-  :keys_200 => generate_data_array_for_spec([4, 4, 3, 4]),
-  :keys_200_flat => generate_data_array_for_spec([200]),
-  :keys_512 => generate_data_array_for_spec([8, 4, 4, 4]),
-  :keys_960 => generate_data_array_for_spec([12, 5, 4, 4]),
-  :keys_2700 => generate_data_array_for_spec([14, 8, 6, 4])
-}
-
-def run_benchmark_and_print_results(data, run_benchmark_func)
-  puts ""
-  puts "Using %s total keys in a hash" % [Scalyr::Common::Util.flatten(data[0]).count]
-  puts ""
-
-  result = []
-  ITERATIONS.times do |i|
-    result << Benchmark.measure { run_benchmark_func.(data[i]) }
-  end
-
-  sum = result.inject(nil) { |sum, t| sum.nil? ? sum = t : sum += t }
-  avg = sum / result.size
-
-  Benchmark.bm(7, "sum:", "avg:") do |b|
-    [sum, avg]
-  end
-  puts ""
-end
-
-puts "Using %s iterations" % [ITERATIONS]
-puts ""
-
-puts "native"
-puts "==============================="
-
-# Around ~50 keys in a hash
-data = DATASETS[:keys_50]
-run_benchmark_and_print_results(data, method(:json_serialize_data_native))
-
-# Around ~200 keys in a hash
-data = DATASETS[:keys_200]
-run_benchmark_and_print_results(data, method(:json_serialize_data_native))
-
-# Around ~200 keys in a hash (single level)
-data = DATASETS[:keys_200_flat]
-run_benchmark_and_print_results(data, method(:json_serialize_data_native))
-
-# Around ~2700 keys in a hash
-data = DATASETS[:keys_2700]
-run_benchmark_and_print_results(data, method(:json_serialize_data_native))
-
-puts "jrjackson"
-puts "==============================="
-
-# Around ~50 keys in a hash
-data = DATASETS[:keys_50]
-run_benchmark_and_print_results(data, method(:json_serialize_data_jrjackson))
-
-# Around ~200 keys in a hash
-data = DATASETS[:keys_200]
-run_benchmark_and_print_results(data, method(:json_serialize_data_jrjackson))
-
-# Around ~200 keys in a hash (single level)
-data = DATASETS[:keys_200_flat]
-run_benchmark_and_print_results(data, method(:json_serialize_data_jrjackson))
-
-# Around ~2700 keys in a hash
-data = DATASETS[:keys_2700]
-run_benchmark_and_print_results(data, method(:json_serialize_data_jrjackson))

data/spec/benchmarks/metrics_overhead.rb

@@ -1,48 +0,0 @@
-require 'benchmark'
-require 'quantile'
-
-require_relative '../../lib/scalyr/common/util'
-
-# Micro benchmark which measures how much overhead Quantile.observe adds vs random sampling to see
-# where making sampling (e.g. on event level metrics) is desired
-
-ITERATIONS = 10000
-
-def run_benchmark_and_print_results(run_benchmark_func)
-  result = []
-  ITERATIONS.times do |i|
-    result << Benchmark.measure { run_benchmark_func.() }
-  end
-
-  sum = result.inject(nil) { |sum, t| sum.nil? ? sum = t : sum += t }
-  avg = sum / result.size
-
-  Benchmark.bm(7, "sum:", "avg:") do |b|
-    [sum, avg]
-  end
-  puts ""
-end
-
-
-puts "Using %s iterations" % [ITERATIONS]
-puts ""
-
-@value = Quantile::Estimator.new
-@prng = Random.new
-
-def quantile_observe()
-  @value.observe(5)
-end
-
-def random_sample()
-  return @prng.rand(0.0..1.0) < 0.5
-end
-
-puts "Quartile.observe()"
-puts "==============================="
-
-run_benchmark_and_print_results(method(:quantile_observe))
-
-puts "random sample"
-puts "==============================="
-run_benchmark_and_print_results(method(:random_sample))

data/spec/benchmarks/set_session_level_serverhost_on_events.rb

@@ -1,107 +0,0 @@
-require 'benchmark'
-require 'quantile'
-
-require_relative '../../lib/scalyr/constants'
-require_relative '../../lib/scalyr/common/util'
-require_relative './util'
-
-# Micro benchmark which measures how long "set_session_level_serverhost_on_events" takes
-
-ITERATIONS = 100
-
-def run_benchmark_and_print_results(data, run_benchmark_func)
-  puts ""
-  puts "Using %s total events in a batch" % [data[0].size]
-  puts ""
-
-  result = []
-  ITERATIONS.times do |i|
-    result << Benchmark.measure { run_benchmark_func.(data[i]) }
-  end
-
-  sum = result.inject(nil) { |sum, t| sum.nil? ? sum = t : sum += t }
-  avg = sum / result.size
-
-  Benchmark.bm(7, "sum:", "avg:") do |b|
-    [sum, avg]
-  end
-  puts ""
-end
-
-# Generate random event with only single event having special server host attribute set which
-# represents a worst case scenario since we need to backfill rest of the events.
-def generate_events(count)
-  result = []
-
-  ITERATIONS.times do |iteration|
-    events = []
-
-    count.times do |index|
-      event = generate_hash([2])
-      event[:attrs] = Hash.new
-      event[:log] = 1
-
-      if index == count - 1
-        event[:attrs][EVENT_LEVEL_SERVER_HOST_ATTRIBUTE_NAME] = format("test-host-%s", index)
-      end
-
-      events << event
-    end
-
-    raise "Assertion failed" unless events.size == count
-
-    result << events
-  end
-
-  raise "Assertion failed" unless result.size == ITERATIONS
-  result
-end
-
-def run_func(events)
-  # NOTE: This function manipulates events in place
-  events.each_with_index do |event, index|
-    if index < events.size - 1
-      # Last event will have _origServerHost set, but others won't
-      raise "Assertion failed" unless event[:attrs][EVENT_LEVEL_SERVER_HOST_ATTRIBUTE_NAME].nil?
-    end
-  end
-
-  Scalyr::Common::Util.set_session_level_serverhost_on_events("session-server-host-dummy", events, {}, true)
-
-  events.each do |event|
-    raise "Assertion failed" unless event[:attrs][EVENT_LEVEL_SERVER_HOST_ATTRIBUTE_NAME].nil? == false
-  end
-end
-
-
-puts "Using %s iterations" % [ITERATIONS]
-puts ""
-
-@value = Quantile::Estimator.new
-
-puts "Util.set_session_level_serverhost_on_events()"
-puts "==============================="
-
-# 100 events in a batch
-data = generate_events(100)
-run_benchmark_and_print_results(data, method(:run_func))
-
-# 500 events in a batch
-data = generate_events(500)
-run_benchmark_and_print_results(data, method(:run_func))
-
-# 1000 events in a batch
-data = generate_events(1000)
-run_benchmark_and_print_results(data, method(:run_func))
-
-# 2000 events in a batch
-data = generate_events(2000)
-run_benchmark_and_print_results(data, method(:run_func))
-
-# 3000 events in a batch
-data = generate_events(3000)
-run_benchmark_and_print_results(data, method(:run_func))
-
-# 5000 events in a batch
-data = generate_events(5000)
-run_benchmark_and_print_results(data, method(:run_func))