logstash-output-graphite-mavlyutov 3.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 136822ceb4a9a17016f9d77316efa454d78d1409
+  data.tar.gz: 74637f2414cfe17add60878e2806b3210915af42
+SHA512:
+  metadata.gz: 9327d6ba1e419f985ec0cc4f21ec99f963f43b1a3434b6785f780edabe56b257494b0eb2b6792db2d1f3fbe8195cc90f9567d3f1c68f87d0dbfbe8fb190640b8
+  data.tar.gz: 014ddb627b0fe85dc74ec4849710c39ee2c4d8f56bbe68d95af394b849dd6cd3dc02a5a2499281ce29ec1ae702784b8be294fd2a771905e91fb67eaa5eb18563

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+## 3.1.1
+  - Relax constraint on logstash-core-plugin-api to >= 1.60 <= 2.99
+
+## 3.1.0
+ - breaking,config: Remove deprecated config `debug`.
+
+## 3.0.1
+ - Republish all the gems under jruby.
+
+## 3.0.0
+ - Update the plugin to the version 2.0 of the plugin api, this change is required for Logstash 5.0 compatibility. See https://github.com/elastic/logstash/issues/5141
+
+## 2.0.5
+ - Depend on logstash-core-plugin-api instead of logstash-core, removing the need to mass update plugins on major releases of logstash
+
+## 2.0.4
+ - New dependency requirements for logstash-core for the 5.0 release
+
+## 2.0.3
+ - Fixed empty/nil messages handling
+
+## 2.0.0
+ - Plugins were updated to follow the new shutdown semantic, this mainly allows Logstash to instruct input plugins to terminate gracefully,
+   instead of using Thread.raise on the plugins' threads. Ref: https://github.com/elastic/logstash/pull/3895
+ - Dependency on logstash-core update to 2.0
+
+## 1.0.2
+ - Added support for sprintf in field formatting
+
+## 1.0.1
+ - Added support for nested hashes as values
+ 

data/CONTRIBUTORS

@@ -0,0 +1,22 @@
+The following is a list of people who have contributed ideas, code, bug
+reports, or in general have helped logstash along its way.
+
+Contributors:
+* Colin Surprenant (colinsurprenant)
+* Dave Snigier (LambdaDriver)
+* John E. Vincent (lusis)
+* Jordan Sissel (jordansissel)
+* Kurt Hurtado (kurtado)
+* Michael Leinartas (mleinart)
+* Pere Urbón (purbon)
+* Pete Fritchman (fetep)
+* Pier-Hugues Pellerin (ph)
+* Rene Lengwinat (invadersmustdie)
+* Richard Pijnenburg (electrical)
+* eravenelle
+* piavlo
+
+Note: If you've sent us patches, bug reports, or otherwise contributed to
+Logstash, and you aren't on the list above and want to be, please let us know
+and we'll make sure you're here. Contributions from folks like you are what make
+open source awesome.

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+logstash_path = ENV["LOGSTASH_PATH"] || "../../logstash"
+use_logstash_source = ENV["LOGSTASH_SOURCE"] && ENV["LOGSTASH_SOURCE"].to_s == "1"
+
+if Dir.exist?(logstash_path) && use_logstash_source
+  gem 'logstash-core', :path => "#{logstash_path}/logstash-core"
+  gem 'logstash-core-plugin-api', :path => "#{logstash_path}/logstash-core-plugin-api"
+end

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2012–2016 Elasticsearch <http://www.elastic.co>
+
+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.

data/NOTICE.TXT

@@ -0,0 +1,5 @@
+Elasticsearch
+Copyright 2012-2015 Elasticsearch
+
+This product includes software developed by The Apache Software
+Foundation (http://www.apache.org/).

data/README.md

@@ -0,0 +1,98 @@
+# Logstash Plugin
+
+[![Travis Build Status](https://travis-ci.org/logstash-plugins/logstash-output-graphite.svg)](https://travis-ci.org/logstash-plugins/logstash-output-graphite)
+
+This is a plugin for [Logstash](https://github.com/elastic/logstash).
+
+It is fully free and fully open source. The license is Apache 2.0, meaning you are pretty much free to use it however you want in whatever way.
+
+## Documentation
+
+Logstash provides infrastructure to automatically generate documentation for this plugin. We use the asciidoc format to write documentation so any comments in the source code will be first converted into asciidoc and then into html. All plugin documentation are placed under one [central location](http://www.elastic.co/guide/en/logstash/current/).
+
+- For formatting code or config example, you can use the asciidoc `[source,ruby]` directive
+- For more asciidoc formatting tips, see the excellent reference here https://github.com/elastic/docs#asciidoc-guide
+
+## Need Help?
+
+Need help? Try #logstash on freenode IRC or the https://discuss.elastic.co/c/logstash discussion forum.
+
+## Developing
+
+### 1. Plugin Developement and Testing
+
+#### Code
+- To get started, you'll need JRuby with the Bundler gem installed.
+
+- Create a new plugin or clone and existing from the GitHub [logstash-plugins](https://github.com/logstash-plugins) organization. We also provide [example plugins](https://github.com/logstash-plugins?query=example).
+
+- Install dependencies
+```sh
+bundle install
+```
+
+#### Test
+
+- Update your dependencies
+
+```sh
+bundle install
+```
+
+- Run tests
+
+```sh
+bundle exec rspec
+```
+
+### 2. Running your unpublished Plugin in Logstash
+
+#### 2.1 Run in a local Logstash clone
+
+- Edit Logstash `Gemfile` and add the local plugin path, for example:
+```ruby
+gem "logstash-filter-awesome", :path => "/your/local/logstash-filter-awesome"
+```
+- Install plugin
+```sh
+# Logstash 2.3 and higher
+bin/logstash-plugin install --no-verify
+
+# Prior to Logstash 2.3
+bin/plugin install --no-verify
+
+```
+- Run Logstash with your plugin
+```sh
+bin/logstash -e 'filter {awesome {}}'
+```
+At this point any modifications to the plugin code will be applied to this local Logstash setup. After modifying the plugin, simply rerun Logstash.
+
+#### 2.2 Run in an installed Logstash
+
+You can use the same **2.1** method to run your plugin in an installed Logstash by editing its `Gemfile` and pointing the `:path` to your local plugin development directory or you can build the gem and install it using:
+
+- Build your plugin gem
+```sh
+gem build logstash-filter-awesome.gemspec
+```
+- Install the plugin from the Logstash home
+```sh
+# Logstash 2.3 and higher
+bin/logstash-plugin install --no-verify
+
+# Prior to Logstash 2.3
+bin/plugin install --no-verify
+
+```
+- Start Logstash and proceed to test the plugin
+
+## Contributing
+
+All contributions are welcome: ideas, patches, documentation, bug reports, complaints, and even something you drew up on a napkin.
+
+Programming is not a required skill. Whatever you've seen about open source and maintainers or community members  saying "send patches or die" - you will not see that here.
+
+It is more important to the community that you are able to contribute.
+
+For more information about contributing, see the [CONTRIBUTING](https://github.com/elastic/logstash/blob/master/CONTRIBUTING.md) file.

data/docs/index.asciidoc

@@ -0,0 +1,172 @@
+:plugin: graphite
+:type: output
+
+///////////////////////////////////////////
+START - GENERATED VARIABLES, DO NOT EDIT!
+///////////////////////////////////////////
+:version: %VERSION%
+:release_date: %RELEASE_DATE%
+:changelog_url: %CHANGELOG_URL%
+:include_path: ../../../logstash/docs/include
+///////////////////////////////////////////
+END - GENERATED VARIABLES, DO NOT EDIT!
+///////////////////////////////////////////
+
+[id="plugins-{type}-{plugin}"]
+
+=== Graphite
+
+include::{include_path}/plugin_header.asciidoc[]
+
+==== Description
+
+This output allows you to pull metrics from your logs and ship them to
+Graphite. Graphite is an open source tool for storing and graphing metrics.
+
+An example use case: Some applications emit aggregated stats in the logs
+every 10 seconds. Using the grok filter and this output, it is possible to
+capture the metric values from the logs and emit them to Graphite.
+
+[id="plugins-{type}s-{plugin}-options"]
+==== Graphite Output Configuration Options
+
+This plugin supports the following configuration options plus the <<plugins-{type}s-common-options>> described later.
+
+[cols="<,<,<",options="header",]
+|=======================================================================
+|Setting |Input type|Required
+| <<plugins-{type}s-{plugin}-exclude_metrics>> |<<array,array>>|No
+| <<plugins-{type}s-{plugin}-fields_are_metrics>> |<<boolean,boolean>>|No
+| <<plugins-{type}s-{plugin}-host>> |<<string,string>>|No
+| <<plugins-{type}s-{plugin}-include_metrics>> |<<array,array>>|No
+| <<plugins-{type}s-{plugin}-metrics>> |<<hash,hash>>|No
+| <<plugins-{type}s-{plugin}-metrics_format>> |<<string,string>>|No
+| <<plugins-{type}s-{plugin}-nested_object_separator>> |<<string,string>>|No
+| <<plugins-{type}s-{plugin}-port>> |<<number,number>>|No
+| <<plugins-{type}s-{plugin}-reconnect_interval>> |<<number,number>>|No
+| <<plugins-{type}s-{plugin}-resend_on_failure>> |<<boolean,boolean>>|No
+| <<plugins-{type}s-{plugin}-timestamp_field>> |<<string,string>>|No
+|=======================================================================
+
+Also see <<plugins-{type}s-common-options>> for a list of options supported by all
+output plugins.
+
+&nbsp;
+
+[id="plugins-{type}s-{plugin}-exclude_metrics"]
+===== `exclude_metrics` 
+
+  * Value type is <<array,array>>
+  * Default value is `["%{[^}]+}"]`
+
+Exclude regex matched metric names, by default exclude unresolved %{field} strings.
+
+[id="plugins-{type}s-{plugin}-fields_are_metrics"]
+===== `fields_are_metrics` 
+
+  * Value type is <<boolean,boolean>>
+  * Default value is `false`
+
+An array indicating that these event fields should be treated as metrics
+and will be sent verbatim to Graphite. You may use either `fields_are_metrics`
+or `metrics`, but not both.
+
+[id="plugins-{type}s-{plugin}-host"]
+===== `host` 
+
+  * Value type is <<string,string>>
+  * Default value is `"localhost"`
+
+The hostname or IP address of the Graphite server.
+
+[id="plugins-{type}s-{plugin}-include_metrics"]
+===== `include_metrics` 
+
+  * Value type is <<array,array>>
+  * Default value is `[".*"]`
+
+Include only regex matched metric names.
+
+[id="plugins-{type}s-{plugin}-metrics"]
+===== `metrics` 
+
+  * Value type is <<hash,hash>>
+  * Default value is `{}`
+
+The metric(s) to use. This supports dynamic strings like %{host}
+for metric names and also for values. This is a hash field with key
+being the metric name, value being the metric value. Example:
+[source,ruby]
+    metrics => { "%{host}/uptime" => "%{uptime_1m}" }
+
+The value will be coerced to a floating point value. Values which cannot be
+coerced will be set to zero (0). You may use either `metrics` or `fields_are_metrics`,
+but not both.
+
+[id="plugins-{type}s-{plugin}-metrics_format"]
+===== `metrics_format` 
+
+  * Value type is <<string,string>>
+  * Default value is `"*"`
+
+Defines the format of the metric string. The placeholder '*' will be
+replaced with the name of the actual metric.
+[source,ruby]
+    metrics_format => "foo.bar.*.sum"
+
+NOTE: If no metrics_format is defined, the name of the metric will be used as fallback.
+
+[id="plugins-{type}s-{plugin}-nested_object_separator"]
+===== `nested_object_separator` 
+
+  * Value type is <<string,string>>
+  * Default value is `"."`
+
+When hashes are passed in as values they are broken out into a dotted notation
+For instance if you configure this plugin with
+# [source,ruby]
+    metrics => "mymetrics"
+
+and "mymetrics" is a nested hash of '{a => 1, b => { c => 2 }}'
+this plugin will generate two metrics: a => 1, and b.c => 2 .
+If you've specified a 'metrics_format' it will respect that,
+but you still may want control over the separator within these nested key names.
+This config setting changes the separator from the '.' default.
+
+[id="plugins-{type}s-{plugin}-port"]
+===== `port` 
+
+  * Value type is <<number,number>>
+  * Default value is `2003`
+
+The port to connect to on the Graphite server.
+
+[id="plugins-{type}s-{plugin}-reconnect_interval"]
+===== `reconnect_interval` 
+
+  * Value type is <<number,number>>
+  * Default value is `2`
+
+Interval between reconnect attempts to Carbon.
+
+[id="plugins-{type}s-{plugin}-resend_on_failure"]
+===== `resend_on_failure` 
+
+  * Value type is <<boolean,boolean>>
+  * Default value is `false`
+
+Should metrics be resent on failure?
+
+[id="plugins-{type}s-{plugin}-timestamp_field"]
+===== `timestamp_field` 
+
+  * Value type is <<string,string>>
+  * Default value is `"@timestamp"`
+
+Use this field for the timestamp instead of '@timestamp' which is the
+default. Useful when backfilling or just getting more accurate data into
+graphite since you probably have a cache layer infront of Logstash.
+
+
+
+include::{include_path}/{type}.asciidoc[]

data/lib/logstash/outputs/graphite.rb

@@ -0,0 +1,226 @@
+# encoding: utf-8
+require "logstash/outputs/base"
+require "logstash/namespace"
+require "socket"
+
+# This output allows you to pull metrics from your logs and ship them to
+# Graphite. Graphite is an open source tool for storing and graphing metrics.
+#
+# An example use case: Some applications emit aggregated stats in the logs
+# every 10 seconds. Using the grok filter and this output, it is possible to
+# capture the metric values from the logs and emit them to Graphite.
+class LogStash::Outputs::Graphite < LogStash::Outputs::Base
+  config_name "graphite"
+
+  EXCLUDE_ALWAYS = [ "@timestamp", "@version" ]
+
+  DEFAULT_METRICS_FORMAT = "*"
+  METRIC_PLACEHOLDER = "*"
+
+  # The hostname or IP address of the Graphite server.
+  config :host, :validate => :string, :default => "localhost", :deprecated => "This setting is being deprecated, use :hosts instead."
+
+  # The port to connect to the Graphite server.
+  config :port, :validate => :number, :default => 2003, :deprecated => "This setting is being deprecated, use :hosts instead."
+
+  # The list of known Graphite servers to connect to. One host is selected randomly (there is no precedence). If one host becomes unreachable, another one is selected randomly.
+  # All entries in this list can contain a port number. If no port number is given, the default value of 2003 is used.
+  config :hosts, :validate => :string, :list => true, :default => ["localhost:2003"]
+
+  # Interval between reconnect attempts to Graphite server, seconds.
+  config :reconnect_interval, :validate => :number, :default => 2
+
+  # Should metrics be resent on failure?
+  config :resend_on_failure, :validate => :boolean, :default => false
+
+  # Number of attempts to be made resending metrics before abandoning
+  config :resend_attempts, :validate => :number, :default => 3
+
+  # The metric(s) to use. This supports dynamic strings like %{host}
+  # for metric names and also for values. This is a hash field with key
+  # being the metric name, value being the metric value. Example:
+  # [source,ruby]
+  #     metrics => { "%{host}/uptime" => "%{uptime_1m}" }
+  #
+  # The value will be coerced to a floating point value. Values which cannot be
+  # coerced will be set to zero (0). You may use either `metrics` or `fields_are_metrics`,
+  # but not both.
+  config :metrics, :validate => :hash, :default => {}
+
+  # An array indicating that these event fields should be treated as metrics
+  # and will be sent verbatim to Graphite. You may use either `fields_are_metrics`
+  # or `metrics`, but not both.
+  config :fields_are_metrics, :validate => :boolean, :default => false
+
+  # Include only regex matched metric names.
+  config :include_metrics, :validate => :array, :default => [ ".*" ]
+
+  # Exclude regex matched metric names, by default exclude unresolved %{field} strings.
+  config :exclude_metrics, :validate => :array, :default => [ "%\{[^}]+\}" ]
+
+  # Use this field for the timestamp instead of '@timestamp' which is the
+  # default. Useful when backfilling or just getting more accurate data into
+  # graphite since you probably have a cache layer infront of Logstash.
+  config :timestamp_field, :validate => :string, :default => '@timestamp'
+
+  # Defines the format of the metric string. The placeholder '*' will be
+  # replaced with the name of the actual metric.
+  # [source,ruby]
+  #     metrics_format => "foo.bar.*.sum"
+  #
+  # NOTE: If no metrics_format is defined, the name of the metric will be used as fallback.
+  config :metrics_format, :validate => :string, :default => DEFAULT_METRICS_FORMAT
+
+  # When hashes are passed in as values they are broken out into a dotted notation
+  # For instance if you configure this plugin with
+  # # [source,ruby]
+  #     metrics => "mymetrics"
+  #
+  # and "mymetrics" is a nested hash of '{a => 1, b => { c => 2 }}'
+  # this plugin will generate two metrics: a => 1, and b.c => 2 .
+  # If you've specified a 'metrics_format' it will respect that,
+  # but you still may want control over the separator within these nested key names.
+  # This config setting changes the separator from the '.' default.
+  config :nested_object_separator, :validate => :string, :default => "."
+
+  def register
+    @include_metrics.collect!{|regexp| Regexp.new(regexp)}
+    @exclude_metrics.collect!{|regexp| Regexp.new(regexp)}
+
+    if @metrics_format && !@metrics_format.include?(METRIC_PLACEHOLDER)
+      @logger.warn("metrics_format does not include placeholder #{METRIC_PLACEHOLDER} .. falling back to default format: #{DEFAULT_METRICS_FORMAT.inspect}")
+
+      @metrics_format = DEFAULT_METRICS_FORMAT
+    end
+
+    setup_hosts
+  end
+
+  def setup_hosts
+    if @hosts && @hosts.size == 1 && @hosts[0] == "localhost:2003"
+      @hosts.replace(["%s:%s" % [@host, @port]])
+    end
+  end
+
+  def send(message)
+    numattempts = 0
+    hosts_to_try = @hosts
+    host = hosts_to_try.sample
+    hosts_to_try.delete(host)
+
+    begin
+      address, _, port = host.rpartition(":")
+      TCPSocket.new(address, port).puts(message)
+    rescue Errno::ECOPNNREFUSED, Errno::EPIPE, Errno::ECONNRESET, IOError
+      if hosts_to_try.size > 0
+        host = hosts_to_try.sample
+        hosts_to_try.delete(host)
+        retry
+      elsif @resend_on_failure && numattempts < @resend_attempts
+        sleep(@reconnect_interval)
+        hosts_to_try = @hosts
+        host = hosts_to_try.sample
+        hosts_to_try.delete(host)
+        numattempts += 1
+        retry
+      else
+        @logger.warn("No more hosts to try, skip sending...")
+      end
+    end
+
+  end
+
+  def construct_metric_name(event, metric)
+    if @metrics_format
+      sprinted = event.sprintf(@metrics_format)
+      return sprinted.gsub(METRIC_PLACEHOLDER, metric)
+    end
+
+    metric
+  end
+
+  def receive(event)
+    # Graphite message format: metric value timestamp\n
+
+    # compact to remove nil messages which produces useless \n
+    messages = (
+      @fields_are_metrics \
+        ? messages_from_event_fields(event, @include_metrics, @exclude_metrics)
+        : messages_from_event_metrics(event, @metrics)
+    ).compact
+
+    if messages.empty?
+      @logger.debug? && @logger.debug("Message is empty, not sending anything to Graphite", :messages => messages)
+    else
+      message = messages.join("\n")
+      @logger.debug? && @logger.debug("Sending carbon messages", :messages => messages)
+
+      send(message)
+    end
+  end
+
+  private
+
+  def messages_from_event_fields(event, include_metrics, exclude_metrics)
+    @logger.debug? && @logger.debug("got metrics event", :metrics => event.to_hash)
+
+    timestamp = event_timestamp(event)
+    event.to_hash.flat_map do |metric,value|
+      next if EXCLUDE_ALWAYS.include?(metric)
+      next unless include_metrics.empty? || include_metrics.any? { |regexp| metric.match(regexp) }
+      next if exclude_metrics.any? {|regexp| metric.match(regexp)}
+
+      metrics_lines_for_event(event, metric, value, timestamp)
+    end
+  end
+
+  def messages_from_event_metrics(event, metrics)
+    timestamp = event_timestamp(event)
+    metrics.flat_map do |metric, value|
+      @logger.debug? && @logger.debug("processing", :metric => metric, :value => value)
+
+      metric = event.sprintf(metric)
+      next unless @include_metrics.any? {|regexp| metric.match(regexp)}
+      next if @exclude_metrics.any? {|regexp| metric.match(regexp)}
+
+      metrics_lines_for_event(event, metric, value, timestamp)
+    end
+  end
+
+  def event_timestamp(event)
+    event.get(@timestamp_field).to_i
+  end
+
+  def metrics_lines_for_event(event, metric, value, timestamp)
+    if event.get(metric).is_a?(Hash)
+      dotify(event.get(metric), metric).map do |k, v|
+        metrics_line(event, k, v, timestamp)
+      end
+    else
+      metrics_line(event, event.sprintf(metric), event.sprintf(value).to_f, timestamp)
+    end
+  end
+
+  def metrics_line(event, name, value, timestamp)
+    "#{construct_metric_name(event, name)} #{value} #{timestamp}"
+  end
+
+  # Take a nested ruby hash of the form {:a => {:b => 2}, c: => 3} and
+  # turn it into a hash of the form
+  # { "a.b" => 2, "c" => 3}
+  def dotify(hash, prefix = nil)
+    hash.reduce({}) do |acc, kv|
+      k, v = kv
+      pk = prefix ? "#{prefix}#{@nested_object_separator}#{k}" : k.to_s
+      if v.is_a?(Hash)
+        acc.merge!(dotify(v, pk))
+      elsif v.is_a?(Array)
+        # There's no right answer here, so we do nothing
+        @logger.warn("Array values not supported for graphite metrics! Ignoring #{hash} @ #{prefix}")
+      else
+        acc[pk] = v
+      end
+      acc
+    end
+  end
+end

data/logstash-output-graphite.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |s|
+
+  s.name            = 'logstash-output-graphite-mavlyutov'
+  s.version         = '3.2.0'
+  s.licenses        = ['Apache License (2.0)']
+  s.summary         = "This output allows you to pull metrics from your logs and ship them to Graphite"
+  s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program"
+  s.authors         = ["Elastic"]
+  s.email           = 'info@elastic.co'
+  s.homepage        = "http://www.elastic.co/guide/en/logstash/current/index.html"
+  s.require_paths = ["lib"]
+
+  # Files
+  s.files = Dir["lib/**/*","spec/**/*","*.gemspec","*.md","CONTRIBUTORS","Gemfile","LICENSE","NOTICE.TXT", "vendor/jar-dependencies/**/*.jar", "vendor/jar-dependencies/**/*.rb", "VERSION", "docs/**/*"]
+
+  # Tests
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+
+  # Special flag to let us know this is actually a logstash plugin
+  s.metadata = { "logstash_plugin" => "true", "logstash_group" => "output" }
+
+  # Gem dependencies
+  s.add_runtime_dependency "logstash-core-plugin-api", ">= 1.60", "<= 2.99"
+
+  s.add_development_dependency 'logstash-devutils'
+  s.add_development_dependency 'logstash-input-generator'
+  s.add_development_dependency 'logstash-filter-kv'
+  s.add_development_dependency 'logstash-filter-ruby'
+end
+

data/spec/outputs/graphite_spec.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+
+require_relative '../spec_helper'
+
+describe LogStash::Outputs::Graphite do
+
+  let(:port) { 4939 }
+  let(:server) { subject.socket }
+
+  before :each do
+    subject.register
+    subject.receive(event)
+  end
+
+  context "with a default run" do
+
+    subject { LogStash::Outputs::Graphite.new("host" => "localhost", "port" => port, "metrics" => [ "hurray.%{foo}", "%{bar}" ]) }
+    let(:event) { LogStash::Event.new("foo" => "fancy", "bar" => 42) }
+
+    it "generate one element" do
+      expect(server.size).to eq(1)
+    end
+
+    it "include all metrics" do
+      line = server.pop
+      expect(line).to match(/^hurray.fancy 42.0 \d{10,}\n$/)
+    end
+  end
+
+  context "if fields_are_metrics => true" do
+    context "when metrics_format => ..." do
+      subject { LogStash::Outputs::Graphite.new("host" => "localhost",
+                                                      "port" => port,
+                                                      "fields_are_metrics" => true,
+                                                      "include_metrics" => ["foo"],
+                                                      "metrics_format" => "foo.%{@host}.sys.data.*") }
+
+      let(:event) { LogStash::Event.new("foo" => "123", "@host" => "testhost") }
+      let(:expected_metric_prefix) { "foo.#{event.get('@host')}.sys.data" }
+
+      context "match one key" do
+        it "should generate one element" do
+          expect(server.size).to eq(1)
+        end
+
+        it "should match the generated key" do
+          line = server.pop
+          expect(line).to match(/^#{expected_metric_prefix}.foo 123.0 \d{10,}\n$/)
+        end
+      end
+
+      context "when matching a nested hash" do
+        let(:event) { LogStash::Event.new("foo" => {"a" => 3, "c" => {"d" => 2}}, "@host" => "myhost") }
+
+        it "should create the proper formatted lines" do
+          lines = [server.pop, server.pop].sort # Put key 'a' first
+          expect(lines[0]).to match(/^#{expected_metric_prefix}.foo.a 3 \d{10,}\n$/)
+          expect(lines[1]).to match(/^#{expected_metric_prefix}.foo.c.d 2 \d{10,}\n$/)
+        end
+      end
+    end
+
+    context "match all keys" do
+
+      subject { LogStash::Outputs::Graphite.new("host" => "localhost",
+                                                      "port" => port,
+                                                      "fields_are_metrics" => true,
+                                                      "include_metrics" => [".*"],
+                                                      "metrics_format" => "foo.bar.sys.data.*") }
+
+      let(:event) { LogStash::Event.new("foo" => "123", "bar" => "42") }
+
+      let(:lines) do
+        dict = {}
+        while(!server.empty?)
+          line = server.pop
+          key  = line.split(' ')[0]
+          dict[key] = line
+        end
+        dict
+      end
+
+      it "match the generated foo key" do
+        expect(lines['foo.bar.sys.data.foo']).to match(/^foo.bar.sys.data.foo 123.0 \d{10,}\n$/)
+      end
+
+      it "match the generated bar key" do
+        expect(lines['foo.bar.sys.data.bar']).to match(/^foo.bar.sys.data.bar 42.0 \d{10,}\n$/)
+      end
+    end
+
+    context "no match" do
+
+      subject { LogStash::Outputs::Graphite.new("host" => "localhost",
+                                                      "port" => port,
+                                                      "fields_are_metrics" => true,
+                                                      "include_metrics" => ["notmatchinganything"],
+                                                      "metrics_format" => "foo.bar.sys.data.*") }
+
+      let(:event) { LogStash::Event.new("foo" => "123", "bar" => "42") }
+
+      it "generate no event" do
+        expect(server.empty?).to eq(true)
+      end
+    end
+
+    context "match a key with invalid metric_format" do
+
+      subject { LogStash::Outputs::Graphite.new("host" => "localhost",
+                                                      "port" => port,
+                                                      "fields_are_metrics" => true,
+                                                      "include_metrics" => ["foo"],
+                                                      "metrics_format" => "invalidformat") }
+
+      let(:event) { LogStash::Event.new("foo" => "123") }
+
+      it "match the foo key" do
+        line = server.pop
+        expect(line).to match(/^foo 123.0 \d{10,}\n$/)
+      end
+    end
+  end
+
+  context "fields are metrics = false" do
+    context "metrics_format not set" do
+      context "match one key with metrics list" do
+
+        subject { LogStash::Outputs::Graphite.new("host" => "localhost",
+                                                        "port" => port,
+                                                        "fields_are_metrics" => false,
+                                                        "include_metrics" => ["foo"],
+                                                        "metrics" => [ "custom.foo", "%{foo}" ]) }
+
+        let(:event) { LogStash::Event.new("foo" => "123") }
+
+        it "match the custom.foo key" do
+          line = server.pop
+          expect(line).to match(/^custom.foo 123.0 \d{10,}\n$/)
+        end
+
+        context "when matching a nested hash" do
+          let(:event) { LogStash::Event.new("custom.foo" => {"a" => 3, "c" => {"d" => 2}}) }
+
+          it "should create the proper formatted lines" do
+            lines = [server.pop, server.pop].sort # Put key 'a' first
+            expect(lines[0]).to match(/^custom.foo.a 3 \d{10,}\n$/)
+            expect(lines[1]).to match(/^custom.foo.c.d 2 \d{10,}\n$/)
+          end
+        end
+      end
+    end
+  end
+
+  context "timestamp_field used is timestamp_new" do
+
+    let(:timestamp_new) { (Time.now + 3).to_i }
+
+    subject { LogStash::Outputs::Graphite.new("host" => "localhost",
+                                                    "port" => port,
+                                                    "timestamp_field" => "timestamp_new",
+                                                    "metrics" => ["foo", "1"]) }
+
+    let(:event) { LogStash::Event.new("foo" => "123", "timestamp_new" => timestamp_new) }
+
+    it "timestamp matches timestamp_new" do
+      line = server.pop
+      expect(line).to match(/^foo 1.0 #{timestamp_new}\n$/)
+    end
+  end
+
+  describe "dotifying a hash" do
+    let(:event) { LogStash::Event.new( "metrics" => hash) }
+    let(:dotified) { LogStash::Outputs::Graphite.new().send(:dotify, hash) }
+
+    context "with a complex hash" do
+      let(:hash) { {:a => 2, :b => {:c => 3, :d => 4, :e => {:f => 5}}} }
+
+      it "should dottify correctly" do
+        expect(dotified).to eql({"a" => 2, "b.c" => 3, "b.d" => 4, "b.e.f" => 5})
+      end
+    end
+
+    context "with a simple hash" do
+      let(:hash) { {:a => 2, 5 => 4} }
+
+      it "should do nothing more than stringify the keys" do
+        expect(dotified).to eql("a" => 2, "5" => 4)
+      end
+    end
+
+    context "with an array value" do
+      let(:hash) { {:a => 2, 5 => 4, :c => [1,2,3]} }
+
+      it "should ignore array values" do
+        expect(dotified).to eql("a" => 2, "5" => 4)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/graphite"
+require_relative "support/server"
+
+class LogStash::Outputs::Graphite
+  attr_reader :socket
+
+  def connect
+    @socket = Mocks::Server.new
+  end
+end

data/spec/support/server.rb

@@ -0,0 +1,29 @@
+module Mocks
+  class Server
+
+    def initialize
+      @queue = Array.new
+    end
+
+    def size
+      @queue.length
+    end
+
+    def pop
+      @queue.pop
+    end
+
+    def stop
+    end
+
+    def empty?
+      @queue.empty?
+    end
+
+    def puts(data)
+      data.split("\n").each do |line|
+        @queue << "#{line}\n"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: logstash-output-graphite-mavlyutov
+version: !ruby/object:Gem::Version
+  version: 3.2.0
+platform: ruby
+authors:
+- Elastic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logstash-core-plugin-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.60'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.60'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '2.99'
+- !ruby/object:Gem::Dependency
+  name: logstash-devutils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logstash-input-generator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logstash-filter-kv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logstash-filter-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem is a Logstash plugin required to be installed on top of the
+  Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This
+  gem is not a stand-alone program
+email: info@elastic.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/logstash/outputs/graphite.rb
+- spec/outputs/graphite_spec.rb
+- spec/spec_helper.rb
+- spec/support/server.rb
+- logstash-output-graphite.gemspec
+- CHANGELOG.md
+- README.md
+- CONTRIBUTORS
+- Gemfile
+- LICENSE
+- NOTICE.TXT
+- docs/index.asciidoc
+homepage: http://www.elastic.co/guide/en/logstash/current/index.html
+licenses:
+- Apache License (2.0)
+metadata:
+  logstash_plugin: 'true'
+  logstash_group: output
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: This output allows you to pull metrics from your logs and ship them to Graphite
+test_files:
+- spec/outputs/graphite_spec.rb
+- spec/spec_helper.rb
+- spec/support/server.rb