logstash-output-scalyr 0.1.5 → 0.1.10.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90d9ce5222a3ea4241a086f8d57ed969afa5af0edb4dfbe47d55af214318d354
-  data.tar.gz: f948a285cfdc401090c66133423bad1db96678c108ba7d508bd76010eb9cf5ac
+  metadata.gz: 290310d36108a3311f55a47efbb3a73e01f19ccdf025a15590f86493459963da
+  data.tar.gz: a5bf9f872c496fa65670cab36e0955f1417541db5f151e11f0d914abe5fc9920
 SHA512:
-  metadata.gz: 4c32b4fc84c642fe54918869479b288adc5f709a4b5d151b27cf52e75f00c4eeb6b96134ae210b935ea9aed628692ad77aa47322b2d72d5b75ba48f1526dd554
-  data.tar.gz: d572c2fcfbdc3a0b9c2fbd3af035803a75de55d2f8f95abc4ce398fecb7fb290b7e90cedf9b771e7d5dcd4fd5759d7fdd312f7ea00f27b9df680ccfed9b79689
+  metadata.gz: 35d60d700b6bb6ccc43aea5151d07c306b29c5524ac8d80145ae792263ffe5e7264d22a59de3a21de9aa549c5963b4cd3c9b230b845f67c6ff9618faca863cad
+  data.tar.gz: 41cf50b968a9a11efff957cda768cf9d05e1ccf3c36e4f4d8f12c3d1aca9fb9da049647432bf047d51c2b6fe33f7b711484632d108dcd390ca852bc45aa7a00d

data/CHANGELOG.md

@@ -1,4 +1,36 @@
 # Beta
+
+## 0.1.10.beta
+
+- Switch to shared concurrency to allow the use of multiple worker threads for increased
+  throughput.
+- Switch HTTP client library to `manticore` to work better with new shared concurrency.
+
+## 0.1.9
+
+- Add support for logging status messages with metrics to stdout in addition to sending this
+  data to Scalyr by setting ``log_status_messages_to_stdout`` config option. By default those
+  lines are logged under INFO log level and you may need to enable / configure pluggin logging
+  as per https://www.elastic.co/guide/en/logstash/current/logging.html.
+- Update metric reporting code to round float values to 4 decimal points so we also record sub
+  millisecond values for per event metrics.
+
+## 0.1.8
+
+- Add additional metrics.
+- Correctly handle flatten_nested_values_duration metric
+- Add support for setting sampling rate for per event level metrics. It defaults to %5 (``0.05``.)
+- Status log line format has been updated so it doesn't include comma between key=value pair to
+  make parser definition a bit simpler.
+
+## 0.1.7
+ - Tracking of new statistics such as `multi_receive` method duration and batch sizes.
+ - Addition of percentiles for both existing and new stats.
+ - Add ability to define a parser name for status messages using the `status_parser` configuration option.
+
+## 0.1.6
+ - Allow for a customer delimiter when flattening values using the `flatten_nested_values_delimiter` configuration option
+
 ## 0.1.2
  - Remove special treatment of `origin` field in favor of `serverHost`
  - Change concurrency type to `single` to help guarantee one-time ordered delivery in Scalyr

data/Gemfile

@@ -12,3 +12,5 @@ end
 
 gem 'pry'
 gem 'pry-nav'
+gem 'quantile'
+gem 'manticore', platform: :jruby

data/README.md

@@ -1,7 +1,7 @@
 
 [![CircleCI](https://circleci.com/gh/scalyr/logstash-output-scalyr.svg?style=svg)](https://circleci.com/gh/scalyr/logstash-output-scalyr)
 
-# [Scalyr output plugin for Logstash (Alpha release)]
+# [Scalyr output plugin for Logstash (Beta release)]
 
 This plugin implements a Logstash output plugin that uploads data to [Scalyr](http://www.scalyr.com).
 
@@ -10,7 +10,7 @@ You can view documentation for this plugin [on the Scalyr website](https://app.s
 # Quick start
 
 1. Build the gem, run `gem build logstash-output-scalyr.gemspec` 
-2. Install the gem into a Logstash installation, run `/usr/share/logstash/bin/logstash-plugin install logstash-output-scalyr-0.1.5.gem` or follow the latest official instructions on working with plugins from Logstash.
+2. Install the gem into a Logstash installation, run `/usr/share/logstash/bin/logstash-plugin install logstash-output-scalyr-0.1.9.gem` or follow the latest official instructions on working with plugins from Logstash.
 3. Configure the output plugin (e.g. add it to a pipeline .conf)
 4. Restart Logstash 
 
@@ -48,7 +48,7 @@ In the above example, the Logstash pipeline defines a file input that reads from
 
 ---
 
-- If your Scalyr backend is located in other geographies (such as Europe which would use `https://agent.eu.scalyr.com/`), you may need to modify this
+- If you have an EU-based Scalyr account, please use https://eu.scalyr.com/
 
 `config :scalyr_server, :validate => :string, :default => "https://agent.scalyr.com/"`
 
@@ -115,6 +115,12 @@ In the above example, the Logstash pipeline defines a file input that reads from
 
 ---
 
+- If set, this will change the delimiter used when concatenating nested keys
+
+`config :flatten_nested_values_delimiter, :validate => :string, :default => "_"`
+
+---
+
 - If true, the 'tags' field will be flattened into key-values where each key is a tag and each value is set to
  :flat_tag_value
 
@@ -152,7 +158,6 @@ In the above example, the Logstash pipeline defines a file input that reads from
 
 # Conceptual Overview
 
-
 ## Persistence
 
 Logstash itself supports [Persistent Queues](https://www.elastic.co/guide/en/logstash/current/persistent-queues.html) with at-least-once delivery semantics.  It expects output plugins to retry uploads until success or else to write failures into a Dead-Letter Queue (DLQ). Since Logstash offers Persistent Queues, the Scalyr plugin does not perform its own buffering or persistence.  More specifically, invocation of `multi_receive` is synchronously retried until success or written to the DLQ upon failure.  Note: the `multi_receive` interface does not provide a feedback mechanism (outcome codes etc).
@@ -301,11 +306,64 @@ This repo has been configured to run a full-cycle smoketest on CircleCI as follo
 This repo has unit tests that can be run by running:
 
 ```
-bundle exec rspec
+sudo bundle exec rspec
 ```
 
 in the root of the repo.
 
+By default this will run all the tests (including integration ones which require sudo access and
+may not pass everywhere).
+
+If you want to run just the unit tests, you can run the command displayed below.
+
+
+```bash
+bundle exec rspec spec/logstash/outputs/scalyr_spec.rb spec/scalyr/common/util_spec.rb
+```
+
+## Instrumentation and metrics
+
+By default, plugin logs a special line with metrics to Scalyr every 5 minutes. This line contains
+various batch, request and event level metrics.
+
+Example line is shown below:
+
+```bash
+plugin_status: total_requests_sent=6 total_requests_failed=0 total_request_bytes_sent=240586 total_compressed_request_bytes_sent=6396 total_response_bytes_received=222 total_request_latency_secs=1.018 total_serialization_duration_secs=0.024 total_compression_duration_secs=0.046 compression_type=deflate compression_level=6 request_latency_p50=0.048 request_latency_p90=0.104 request_latency_p99=0.104 serialization_duration_secs_p50=0.003 serialization_duration_secs_p90=0.005 serialization_duration_secs_p99=0.005 compression_duration_secs_p50=0.006 compression_duration_secs_p90=0.013 compression_duration_secs_p99=0.013 bytes_sent_p50=40116 bytes_sent_p90=40116 bytes_sent_p99=40116 total_multi_receive_secs=1.404 multi_receive_duration_p50=0.083 multi_receive_duration_p90=0.192 multi_receive_duration_p99=0.192 multi_receive_event_count_p50=100 multi_receive_event_count_p90=100 multi_receive_event_count_p99=100 event_attributes_count_p50=8 event_attributes_count_p90=8 event_attributes_count_p99=8 flatten_values_duration_secs_p50=0 flatten_values_duration_secs_p90=0 flatten_values_duration_secs_p99=0
+```
+
+Those lines also have ``logstash_plugin_metrics`` ``parser`` attribute defined which means you
+can easily parse them using a parser definition similar to the one below.
+
+```javascript
+{
+    patterns: {
+      nonQuoted: "[^\"\n ]+"
+  },
+
+  formats: [
+    {
+      format: ".* $_=identifier$=$_=nonQuoted$", repeat: true
+    }
+  ]
+}
+```
+
+Do keep in mind that this line contains quite a lot of metrics so parsing it may make it more likely
+to hit server side defined per 5 minute period unique number of attributes limit in case you are already
+very close to tke limit.
+
+For various request level metrics we track totals (either counts or duration). Those metrics names start
+with ``total_`` (e.g. ``total_requests_failed``). To be able to derive average per request values you
+can do that by dividing the total value with the value of ``total_requests_sent`` metrics.
+
+Because averages are not all that useful we also track percentiles for various request, batch and
+event level metrics. Those metrics names end with ``_p{percentile}``. For example ``_p50`` represents
+50th percentile and ``_p99`` represents 99th percentile (e.g. ``request_latency_p99``).
+
+If you want to change status reporting interval you can do that by changing the
+``status_report_interval`` config option (in seconds).
+
 # Releasing
 
 ## Updating version
@@ -320,6 +378,7 @@ The changelog should also be updated with the latest version and changes of note
 To deploy the current code on your machine run these commands:
 
 ```
+rm -rf vendor/
 bundle check --path vendor/bundle || bundle install --deployment
 curl -u RUBY_USER:RUBY_PASSWORD https://rubygems.org/api/v1/api_key.yaml > ~/.gem/credentials
 chmod 0600 ~/.gem/credentials

data/lib/logstash/outputs/scalyr.rb

@@ -8,12 +8,11 @@ require "thread" # for safe queueing
 require "uri" # for escaping user input
 require 'json' # for converting event object to JSON for upload
 
-require 'net/http'
-require 'net/http/persistent'
-require 'net/https'
+require 'manticore'
 require 'rbzip2'
 require 'zlib'
 require 'stringio'
+require 'quantile'
 
 require 'scalyr/common/client'
 require "scalyr/common/util"
@@ -26,22 +25,14 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
 
   config_name "scalyr"
 
-  # For correctness reasons we need to limit this plugin to a single worker, a single worker will be single concurrency
-  # anyway but we should be explicit.
-  concurrency :single
+  concurrency :shared
 
   # The Scalyr API write token, these are available at https://www.scalyr.com/keys.  This is the only compulsory configuration field required for proper upload
   config :api_write_token, :validate => :string, :required => true
 
-  # If your Scalyr backend is located in other geographies (such as Europe which would use `https://agent.eu.scalyr.com/`), you may need to modify this
+  # If you have an EU-based Scalyr account, please use https://eu.scalyr.com/
   config :scalyr_server, :validate => :string, :default => "https://agent.scalyr.com/"
 
-  # Path to SSL bundle file.
-  config :ssl_ca_bundle_path, :validate => :string, :default => "/etc/ssl/certs/ca-bundle.crt"
-
-  # If we should append our built-in Scalyr cert to the one we find at `ssl_ca_bundle_path`.
-  config :append_builtin_cert, :validate => :boolean, :default => true
-
   # server_attributes is a dictionary of key value pairs that represents/identifies the logstash aggregator server
   # (where this plugin is running).  Keys are arbitrary except for the 'serverHost' key which holds special meaning to
   # Scalyr and is given special treatment in the Scalyr UI.  All of these attributes are optional (not required for logs
@@ -76,6 +67,7 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
   # If true, nested values will be flattened (which changes keys to delimiter-separated concatenation of all
   # nested keys).
   config :flatten_nested_values, :validate => :boolean, :default => false
+  config :flatten_nested_values_delimiter, :validate => :string, :default => "_" 
 
   # If true, the 'tags' field will be flattened into key-values where each key is a tag and each value is set to
   # :flat_tag_value
@@ -89,9 +81,14 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
   # Set max interval in seconds between bulk retries.
   config :retry_max_interval, :validate => :number, :default => 64
 
-  # The following two settings pertain to preventing Man-in-the-middle (MITM) attacks  # echee TODO: eliminate?
+  # Whether or not to verify the connection to Scalyr, only set to false for debugging.
   config :ssl_verify_peer, :validate => :boolean, :default => true
-  config :ssl_verify_depth, :validate => :number, :default => 5
+
+  # Path to SSL bundle file.
+  config :ssl_ca_bundle_path, :validate => :string, :default => "/etc/ssl/certs/ca-bundle.crt"
+
+  # If we should append our built-in Scalyr cert to the one we find at `ssl_ca_bundle_path`.
+  config :append_builtin_cert, :validate => :boolean, :default => true
 
   config :max_request_buffer, :validate => :number, :default => 5500000  # echee TODO: eliminate?
   config :force_message_encoding, :validate => :string, :default => nil
@@ -103,6 +100,52 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
   # An int containing the compression level of compression to use, from 1-9. Defaults to 6
   config :compression_level, :validate => :number, :default => 6
 
+  # How often to log and report status metrics to Scalyr. Defaults to every 5
+  # minutes.
+  config :status_report_interval, :validate => :number, :default => 300
+
+  # Set to true to also log status messages with various metrics to stdout in addition to sending
+  # this data to Scalyr
+  config :log_status_messages_to_stdout, :validate => :boolean, :default => false
+
+  # Whether or not to count status event uploads in the statistics such as request latency etc.
+  config :record_stats_for_status, :validate => :boolean, :default => false
+
+  # Sample rate for event level metrics (flattening time, number of attributes per event, etc,).
+  # It's important to set this in case there are many events coming in per seconds, because
+  # instrumentation does add some overhead. By default, we sample 5% of the events. Keep in
+  # mind that we use simple random based sampling. Maximum possible value is 1 (aka no sampling
+  # - record metrics for every single event).
+  # We use sampling since Quantile.observe() operation is more expensive than simple counter
+  # based metric so we need to ensure recording a metric doesn't add too much overhead.
+  # Based on micro benchmark, random based sampler is about 5x faster than quantile.observe()
+  config :event_metrics_sample_rate, :validate => :number, :default => 0.05
+
+  # Parser to attach to status events
+  config :status_parser, :validate => :string, :default => "logstash_plugin_metrics"
+
+  # Whether or not to create fresh quantile estimators after a status send. Depending on what you want to gather from
+  # these stas this might be wanted or not.
+  config :flush_quantile_estimates_on_status_send, :validate => :boolean, :default => false
+  
+  # Causes this plugin to act as if it successfully uploaded the logs, while actually returning as quickly as possible
+  # after no work being done.
+  config :noop_mode, :validate => :boolean, :default => false
+
+  # Manticore related options
+  config :http_connect_timeout, :validate => :number, :default => 10
+  config :http_socket_timeout, :validate => :number, :default => 10
+  config :http_request_timeout, :validate => :number, :default => 60
+  config :http_pool_max, :validate => :number, :default => 50
+  config :http_pool_max_per_route, :validate => :number, :default => 25
+
+  def initialize(*params)
+    super
+    # Request statistics are accumulated across multiple threads and must be accessed through a mutex
+    @stats_lock = Mutex.new
+    @send_stats = Mutex.new
+  end
+
   def close
     @running = false
     @client_session.close if @client_session
@@ -110,6 +153,14 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
 
   public
   def register
+    # This prng is used exclusively to determine when to sample statistics and no security related purpose, for this
+    # reason we do not ensure thread safety for it.
+    @prng = Random.new
+
+    if @event_metrics_sample_rate < 0 or @event_metrics_sample_rate > 1
+      raise LogStash::ConfigurationError, "Minimum possible value for 'event_metrics_sample_rate' is 0 (dont sample any events) and maximum is 1 (sample every event)"
+    end
+
     @node_hostname = Socket.gethostname
 
     if @log_constants and not @log_constants.all? { |x| x.is_a? String }
@@ -176,13 +227,20 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
     @last_status_transmit_time = nil
     @last_status_ = false
 
+    # Plugin level (either per batch or event level metrics). Other request
+    # level metrics are handled by the HTTP Client class.
+    @multi_receive_statistics = {
+      :total_multi_receive_secs => 0
+    }
+    @plugin_metrics = get_new_metrics
+
     # create a client session for uploading to Scalyr
     @running = true
     @client_session = Scalyr::Common::Client::ClientSession.new(
         @logger, @add_events_uri,
-        @compression_type, @compression_level,
-        @ssl_verify_peer, @ssl_ca_bundle_path, @ssl_verify_depth,
-        @append_builtin_cert
+        @compression_type, @compression_level, @ssl_verify_peer, @ssl_ca_bundle_path, @append_builtin_cert,
+        @record_stats_for_status, @flush_quantile_estimates_on_status_send,
+        @http_connect_timeout, @http_socket_timeout, @http_request_timeout, @http_pool_max, @http_pool_max_per_route
     )
 
     @logger.info("Started Scalyr output plugin", :class => self.class.name)
@@ -192,6 +250,15 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
 
   end # def register
 
+  # Convenience method to create a fresh quantile estimator
+  def get_new_metrics
+    return {
+      :multi_receive_duration_secs => Quantile::Estimator.new,
+      :multi_receive_event_count => Quantile::Estimator.new,
+      :event_attributes_count => Quantile::Estimator.new,
+      :flatten_values_duration_secs => Quantile::Estimator.new
+    }
+  end
 
   # Receive an array of events and immediately upload them (without buffering).
   # The Logstash framework will call this plugin method whenever there is a list of events to upload to Scalyr.
@@ -205,6 +272,10 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
   #
   public
   def multi_receive(events)
+    # Just return and pretend we did something if running in noop mode
+    return events if @noop_mode
+
+    start_time = Time.now.to_f
 
     multi_event_request_array = build_multi_event_request_array(events)
     # Loop over all array of multi-event requests, sending each multi-event to Scalyr
@@ -214,22 +285,25 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
     total_batches = multi_event_request_array.length unless multi_event_request_array.nil?
 
     result = []
+    records_count = events.to_a.length
+
     while !multi_event_request_array.to_a.empty?
       begin
         multi_event_request = multi_event_request_array.pop
         # For some reason a retry on the multi_receive may result in the request array containing `nil` elements, we
         # ignore these.
         if !multi_event_request.nil?
-          @client_session.post_add_events(multi_event_request[:body])
+          @client_session.post_add_events(multi_event_request[:body], false, multi_event_request[:serialization_duration])
+
           sleep_interval = 0
           result.push(multi_event_request)
         end
 
       rescue OpenSSL::SSL::SSLError => e
         # cannot rely on exception message, so we always log the following warning
-        @logger.error "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.  "
+        @logger.error "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}'"
         @logger.error e.message
         @logger.error "Discarding buffer chunk without retrying."
@@ -251,7 +325,7 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
         exc_data[:payload] = "\tSample payload: #{request[:body][0,1024]}..." if @logger.debug?
         if e.is_commonly_retried?
           # well-known retriable errors should be debug
-          @logger.debug(message, exc_data)
+          @logger.error(message, exc_data)
         else
           # all other failed uploads should be errors
           @logger.error(message, exc_data)
@@ -272,6 +346,14 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
       end
     end
 
+    if records_count > 0
+      @stats_lock.synchronize do
+        @multi_receive_statistics[:total_multi_receive_secs] += (Time.now.to_f - start_time)
+        @plugin_metrics[:multi_receive_duration_secs].observe(Time.now.to_f - start_time)
+        @plugin_metrics[:multi_receive_event_count].observe(records_count)
+      end
+    end
+
     send_status
     return result
   end  # def multi_receive
@@ -295,6 +377,9 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
   # Tags are either propagated as a comma-separated string, or optionally transposed into key-values where the keys
   # are tag names and the values are 1 (may be configured.)
   def build_multi_event_request_array(logstash_events)
+    if logstash_events.nil? or logstash_events.empty?
+     return []
+    end
 
     multi_event_request_array = Array.new
     total_bytes = 0
@@ -337,8 +422,8 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
         if standard_field != renamed_field
           if record.key? renamed_field
             if record.key? standard_field
-              @logger.warn "Overwriting log record field '#{standard_field}'.  You are seeing this warning because in "
-              "your LogStash config file you have configured the '#{renamed_field}' field to be converted to the "
+              @logger.warn "Overwriting log record field '#{standard_field}'.  You are seeing this warning because in " +
+              "your LogStash config file you have configured the '#{renamed_field}' field to be converted to the " +
               "'#{standard_field}' field, but the event already contains a field called '#{standard_field}' and "
               "this is now being overwritten."
             end
@@ -424,8 +509,27 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
         record.delete('tags')
       end
 
+      # Record per-event level metrics (flatten duration, event attributes count). Doing this for every single
+      # event would be somewhat expensive so we use sampling.
+      should_sample_event_metrics = should_sample?
+
       # flatten record
-      record = Scalyr::Common::Util.flatten(record) if @flatten_nested_values
+      if @flatten_nested_values
+        start_time = Time.now.to_f
+        record = Scalyr::Common::Util.flatten(record, delimiter=@flatten_nested_values_delimiter)
+        end_time = Time.now.to_f
+        flatten_nested_values_duration = end_time - start_time
+      end
+
+      if should_sample_event_metrics
+        @stats_lock.synchronize do
+          @plugin_metrics[:event_attributes_count].observe(record.count)
+
+          if @flatten_nested_values
+            @plugin_metrics[:flatten_values_duration_secs].observe(flatten_nested_values_duration)
+          end
+        end
+      end
 
       # Use LogStash event.timestamp as the 'ts' Scalyr timestamp.  Note that this may be overwritten by input
       # filters so may not necessarily reflect the actual originating timestamp.
@@ -502,7 +606,6 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
   end
 
 
-
   # Helper method that adds a client_timestamp to a batch addEvents request body
   def add_client_timestamp_to_body(body)
     current_time_millis = DateTime.now.strftime('%Q').to_i
@@ -512,14 +615,13 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
   end
 
 
-
   # A request comprises multiple Scalyr Events.  This function creates a request hash for
   # final upload to Scalyr (from an array of events, and an optional hash of current threads)
   # Note: The request body field will be json-encoded.
   def create_multi_event_request(scalyr_events, current_threads, current_logs)
 
     body = {
-      :session => @session_id,
+      :session => @session_id + Thread.current.object_id.to_s,
       :token => @api_write_token,
       :events => scalyr_events,
     }
@@ -547,11 +649,48 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
     # add serverAttributes
     body[:sessionInfo] = @server_attributes if @server_attributes
 
-    { :body => body.to_json, :record_count => scalyr_events.size }
+    # We time serialization to get some insight on how long it takes to serialize the request body
+    start_time = Time.now.to_f
+    serialized_body = body.to_json
+    end_time = Time.now.to_f
+    serialization_duration = end_time - start_time
+    { :body => serialized_body, :record_count => scalyr_events.size, :serialization_duration => serialization_duration }
 
   end  # def create_multi_event_request
 
 
+  # Retrieve batch and other event level metric values
+  def get_stats
+    @stats_lock.synchronize do
+      current_stats = @multi_receive_statistics.clone
+
+      current_stats[:multi_receive_duration_p50] = @plugin_metrics[:multi_receive_duration_secs].query(0.5)
+      current_stats[:multi_receive_duration_p90] = @plugin_metrics[:multi_receive_duration_secs].query(0.9)
+      current_stats[:multi_receive_duration_p99] = @plugin_metrics[:multi_receive_duration_secs].query(0.99)
+
+      current_stats[:multi_receive_event_count_p50] = @plugin_metrics[:multi_receive_event_count].query(0.5)
+      current_stats[:multi_receive_event_count_p90] = @plugin_metrics[:multi_receive_event_count].query(0.9)
+      current_stats[:multi_receive_event_count_p99] = @plugin_metrics[:multi_receive_event_count].query(0.99)
+
+      current_stats[:event_attributes_count_p50] = @plugin_metrics[:event_attributes_count].query(0.5)
+      current_stats[:event_attributes_count_p90] = @plugin_metrics[:event_attributes_count].query(0.9)
+      current_stats[:event_attributes_count_p99] = @plugin_metrics[:event_attributes_count].query(0.99)
+
+      if @flatten_nested_values
+        # We only return those metrics in case flattening is enabled
+        current_stats[:flatten_values_duration_secs_p50] = @plugin_metrics[:flatten_values_duration_secs].query(0.5)
+        current_stats[:flatten_values_duration_secs_p90] = @plugin_metrics[:flatten_values_duration_secs].query(0.9)
+        current_stats[:flatten_values_duration_secs_p99] = @plugin_metrics[:flatten_values_duration_secs].query(0.99)
+      end
+
+      if @flush_quantile_estimates_on_status_send
+        @logger.debug "Recreating / reseting quantile estimator classes for plugin metrics"
+        @plugin_metrics = get_new_metrics
+      end
+
+      current_stats
+    end
+  end
 
 
   # Sends a status update to Scalyr by posting a log entry under the special logfile of 'logstash_plugin.log'
@@ -569,37 +708,57 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
         'plugin_id' => self.id,
       }
     }
-
-    if !@last_status_transmit_time
-      status_event[:attrs]['message'] = "Started Scalyr LogStash output plugin."
-      status_event[:attrs]['serverHost'] = @node_hostname
-    else
-      cur_time = Time.now()
-      return if (cur_time.to_i - @last_status_transmit_time.to_i) < 300
-      # echee TODO: get instance stats from session and create a status log line
-      msg = 'plugin_status: '
-      cnt = 0
-      @client_session.get_stats.each do |k, v|
-        val = v.instance_of?(Float) ? sprintf("%.1f", v) : v
-        msg << ', ' if cnt > 0
-        msg << "#{k.to_s}=#{val}"
-        cnt += 1
+    @send_stats.synchronize do
+      if !@last_status_transmit_time
+        status_event[:attrs]['message'] = "Started Scalyr LogStash output plugin."
+        status_event[:attrs]['serverHost'] = @node_hostname
+      else
+        cur_time = Time.now()
+        return if (cur_time.to_i - @last_status_transmit_time.to_i) < @status_report_interval
+        # echee TODO: get instance stats from session and create a status log line
+        msg = 'plugin_status: '
+        cnt = 0
+        @client_session.get_stats.each do |k, v|
+          val = v.instance_of?(Float) ? sprintf("%.4f", v) : v
+          val = val.nil? ? 0 : val
+          msg << ' ' if cnt > 0
+          msg << "#{k.to_s}=#{val}"
+          cnt += 1
+        end
+        get_stats.each do |k, v|
+          val = v.instance_of?(Float) ? sprintf("%.4f", v) : v
+          val = val.nil? ? 0 : val
+          msg << ' ' if cnt > 0
+          msg << "#{k.to_s}=#{val}"
+          cnt += 1
+        end
+        status_event[:attrs]['message'] = msg
+        status_event[:attrs]['serverHost'] = @node_hostname
+        status_event[:attrs]['parser'] = @status_parser
       end
-      status_event[:attrs]['message'] = msg
-      status_event[:attrs]['serverHost'] = @node_hostname
     end
     multi_event_request = create_multi_event_request([status_event], nil, nil)
-    @client_session.post_add_events(multi_event_request[:body])
+    @client_session.post_add_events(multi_event_request[:body], true, 0)
     @last_status_transmit_time = Time.now()
+
+    if @log_status_messages_to_stdout
+      @logger.info msg
+    end
+    status_event
   end
 
+  # Returns true if we should sample and record metrics for a specific event based on the sampling
+  # rate and random value
+  def should_sample?
+    return @prng.rand(0.0..1.0) < @event_metrics_sample_rate
+  end
 
 
   # Returns true if it is time to transmit status
   def should_transmit_status?
     @last_status_transmit_time_lock.synchronize do
       saved_last_time = @last_status_transmit_time
-      if Time.now.to_i - saved_last_time.to_i > 300
+      if Time.now.to_i - saved_last_time.to_i > @status_report_interval
         @last_status_transmit_time = Float::INFINITY
         return saved_last_time
       end
@@ -621,12 +780,10 @@ class LogStash::Outputs::Scalyr < LogStash::Outputs::Base
   end
 
 
-
   # Helper method to check if the dead-letter queue is enabled
   def dlq_enabled?
     # echee TODO submit to DLQ
     respond_to?(:execution_context) && execution_context.respond_to?(:dlq_writer) &&
         !execution_context.dlq_writer.inner_writer.is_a?(::LogStash::Util::DummyDeadLetterQueueWriter)
   end
-
 end