logstash-output-graphite 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e9fa433c20de3668a25403281f5cbb3ae7952d6
-  data.tar.gz: 6391b1f0137f1f637ecd656f3f04f5898c298f31
+  metadata.gz: b6d50a691df186d1f6b3c9a19c496308afe70d39
+  data.tar.gz: 8e734363fe5ecca3ab719235691b2a1d0e6c3bd7
 SHA512:
-  metadata.gz: da65eb4c3edf08e6b327e771204817a877f619713c4fba06d3611cb9235636ca5b2436ac027fc3ca32aa4ccf4e08a332929ac0e94a73e8f158efe29a6533dc7a
-  data.tar.gz: 564c8b7cc09740c14baf91f4626d6d8b9f85b38b51951274c8ed85cd2f51c2ef284e44d5b00b04934ebe3b4447abb7e82e7b2e083f3e937d2a0ac6b35368f431
+  metadata.gz: b83527c9bc1003809fd2e99a942a24e3317c336bec19a8e4a9ca178fa5fac84ebb45474f10b9c25a3c1dc5985c554e9f32789f845ec3e400cc8f939c92365515
+  data.tar.gz: 76b8223c213425a7ca8628f2ae1c77f2652841b463392b12f25392cdf1250bf4de3f2105065333ae1e66f84fa996fa21487fe4bb2e8c620bf04466b33bcc740d

data/logstash-output-graphite.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-output-graphite'
-  s.version         = '0.1.7'
+  s.version         = '0.1.8'
   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/plugin install gemname. This gem is not a stand-alone program"

data/spec/outputs/graphite_spec.rb

@@ -3,208 +3,107 @@ require_relative '../spec_helper'
 describe LogStash::Outputs::Graphite do
 
   let(:port) { 4939 }
-  let(:config) do <<-CONFIG
-     input {
-        generator {
-          message => "foo=fancy bar=42"
-          count => 1
-          type => "generator"
-        }
-      }
-
-      filter {
-        kv { }
-      }
-
-      output {
-        graphite {
-          host => "localhost"
-          port => #{port}
-          metrics => [ "hurray.%{foo}", "%{bar}" ]
-        }
-      }
-  CONFIG
-  end
-
-  let(:pipeline) { LogStash::Pipeline.new(config) }
-  let(:server)   { Mocks::Server.new(port) }
+  let(:server) { subject.socket }
 
-  before do
-    server.start
-    pipeline.run
-  end
-
-  after do
-    server.stop
+  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
-      lines = server.pop
-      expect(lines).to match(/^hurray.fancy 42.0 \d{10,}\n$/)
+      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.bar.sys.data.*") }
 
-      context "match one key" do
-        let(:config) do <<-CONFIG
-          input {
-            generator {
-              message => "foo=123"
-              count => 1
-              type => "generator"
-            }
-          }
-
-          filter {
-            kv { }
-          }
-
-          output {
-            graphite {
-                host => "localhost"
-                port => #{port}
-                fields_are_metrics => true
-                include_metrics => ["foo"]
-                metrics_format => "foo.bar.sys.data.*"
-                debug => true
-            }
-          }
-        CONFIG
-        end
+      let(:event) { LogStash::Event.new("foo" => "123") }
 
+      context "match one key" do
         it "generate one element" do
           expect(server.size).to eq(1)
         end
 
         it "match the generated key" do
-          lines = server.pop
-          expect(lines).to match(/^foo.bar.sys.data.foo 123.0 \d{10,}\n$/)
+          line = server.pop
+          expect(line).to match(/^foo.bar.sys.data.foo 123.0 \d{10,}\n$/)
         end
-
       end
+    end
 
-      context "match all keys" do
-
-        let(:config) do <<-CONFIG
-          input {
-            generator {
-              message => "foo=123 bar=42"
-              count => 1
-              type => "generator"
-            }
-          }
-
-          filter {
-            kv { }
-          }
-
-          output {
-            graphite {
-                host => "localhost"
-                port => #{port}
-                fields_are_metrics => true
-                include_metrics => [".*"]
-                metrics_format => "foo.bar.sys.data.*"
-                debug => true
-            }
-          }
-        CONFIG
-        end
+    context "match all keys" do
 
-        let(:lines) do
-          dict = {}
-          while(!server.empty?)
-            line = server.pop
-            key  = line.split(' ')[0]
-            dict[key] = line
-          end
-          dict
-        end
+      subject { LogStash::Outputs::Graphite.new("host" => "localhost",
+                                                      "port" => port,
+                                                      "fields_are_metrics" => true,
+                                                      "include_metrics" => [".*"],
+                                                      "metrics_format" => "foo.bar.sys.data.*") }
 
-        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
+      let(:event) { LogStash::Event.new("foo" => "123", "bar" => "42") }
 
-        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$/)
+      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
 
-      context "no match" do
-
-        let(:config) do  <<-CONFIG
-          input {
-            generator {
-              message => "foo=123 bar=42"
-              count => 1
-              type => "generator"
-            }
-          }
-
-          filter {
-            kv { }
-          }
-
-          output {
-            graphite {
-              host => "localhost"
-              port => #{port}
-              fields_are_metrics => true
-              include_metrics => ["notmatchinganything"]
-              metrics_format => "foo.bar.sys.data.*"
-              debug => true
-            }
-          }
-        CONFIG
-        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
 
-        it "generate no event" do
-          expect(server.empty?).to eq(true)
-        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
-
-        let(:config) do <<-CONFIG
-          input {
-            generator {
-              message => "foo=123"
-              count => 1
-              type => "generator"
-            }
-          }
-
-          filter {
-            kv { }
-          }
-
-          output {
-            graphite {
-                host => "localhost"
-                port => #{port}
-                fields_are_metrics => true
-                include_metrics => ["foo"]
-                metrics_format => "invalidformat"
-                debug => true
-            }
-          }
-        CONFIG
-        end
+    context "match a key with invalid metric_format" do
 
-        it "match the foo key" do
-          lines = server.pop
-          expect(lines).to match(/^foo 123.0 \d{10,}\n$/)
-        end
+      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
@@ -213,75 +112,36 @@ describe LogStash::Outputs::Graphite do
     context "metrics_format not set" do
       context "match one key with metrics list" do
 
-        let(:config) do <<-CONFIG
-          input {
-            generator {
-              message => "foo=123"
-              count => 1
-              type => "generator"
-            }
-          }
-
-          filter {
-            kv { }
-          }
-
-          output {
-            graphite {
-                host => "localhost"
-                port => #{port}
-                fields_are_metrics => false
-                include_metrics => ["foo"]
-                metrics => [ "custom.foo", "%{foo}" ]
-                debug => true
-            }
-          }
-        CONFIG
-        end
+        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
-          lines = server.pop
-          expect(lines).to match(/^custom.foo 123.0 \d{10,}\n$/)
+          line = server.pop
+          expect(line).to match(/^custom.foo 123.0 \d{10,}\n$/)
         end
-
       end
     end
   end
 
   context "timestamp_field used is timestamp_new" do
-    timestamp_new = (Time.now + 3).to_i
-    let(:config) do <<-CONFIG
-          input {
-            generator {
-              message => "foo=123"
-              count => 1
-              type => "generator"
-            }
-          }
-
-          filter {
-            ruby {
-              code => "event['timestamp_new'] = Time.at(#{timestamp_new})"
-            }
-          }
-
-          output {
-            graphite {
-                host => "localhost"
-                port => #{port}
-                timestamp_field => "timestamp_new"
-                metrics => ["foo", "1"]
-                debug => true
-            }
-          }
-    CONFIG
-    end
+
+    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
-      lines = server.pop
-      expect(lines).to match(/^foo 1.0 #{timestamp_new}\n$/)
+      line = server.pop
+      expect(line).to match(/^foo 1.0 #{timestamp_new}\n$/)
     end
-
   end
-
 end

data/spec/spec_helper.rb

@@ -1,3 +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

@@ -1,24 +1,8 @@
 module Mocks
   class Server
 
-    def initialize(port)
-      @queue = Queue.new
-      @port  = port
-    end
-
-    def start
-      @server = TCPServer.new("127.0.0.1", @port)
-      @queue.clear
-      Thread.new do
-        client = @server.accept
-        while true
-          if !client.eof?
-            line = client.readline
-            @queue << line
-          end
-        end
-      end
-      self
+    def initialize
+      @queue = Array.new
     end
 
     def size
@@ -30,12 +14,16 @@ module Mocks
     end
 
     def stop
-      @server.close
     end
 
     def empty?
       @queue.empty?
     end
 
+    def puts(data)
+      data.split("\n").each do |line|
+        @queue << "#{line}\n"
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-graphite
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-04-20 00:00:00.000000000 Z
+date: 2015-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -125,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.1.9
+rubygems_version: 2.4.5
 signing_key:
 specification_version: 4
 summary: This output allows you to pull metrics from your logs and ship them to Graphite