logstash-output-email 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MGExYjgwYzBlYTE4OGRjY2I1YjQ0MzdkZjNjZjliNWEwNDM4OTcxZg==
+  data.tar.gz: !binary |-
+    OTQ5MWUwNjhjNzNjMDQ5OTk5YzAyOWE4MzRkMzIwNWJiYTJmYzEwNQ==
+SHA512:
+  metadata.gz: !binary |-
+    NzRiYmFjMjM5MjliYzVmZDQwNzQ3Mjk0NDBlMjg3ZGJkZGY4YjkwZDQ2Zjkw
+    MDc1OGQ2Mzc4N2U4NTM0ODVlMGQ5MTQzMjE2ZDc1NTM4NWIwYThjMjU4OWUw
+    NGM1YmNmYTVmM2U1ZjVlYTIwYzk1ZmI4ZjY3YTJjODQyMjg3YTA=
+  data.tar.gz: !binary |-
+    MGE4Y2U3ZjM2M2QyNzIxNDcxYWUwNmFlNThlMjZlNGEzZDA2M2Q4ZTMyMzQw
+    MTljZmMzYzJmZDA5Y2M4ZjRiY2U4MzIzYWM5YjNlNThkZDM4NGFlNWY3Nzk2
+    MTc2ZTRlYThhYjU2MjhjNjllZTcxMmI1MDQ3ODAzZjkxNGVkZDg=

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+Gemfile.lock
+.bundle
+vendor

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+gem 'rake'
+gem 'gem_publisher'
+gem 'archive-tar-minitar'

data/Rakefile

@@ -0,0 +1,6 @@
+@files=[]
+
+task :default do
+  system("rake -T")
+end
+

data/lib/logstash/outputs/email.rb

@@ -0,0 +1,303 @@
+# encoding: utf-8
+require "logstash/outputs/base"
+require "logstash/namespace"
+
+# Send email when an output is received. Alternatively, you may include or
+# exclude the email output execution using conditionals. 
+class LogStash::Outputs::Email < LogStash::Outputs::Base
+
+  config_name "email"
+  milestone 1
+
+  # This setting is deprecated in favor of Logstash's "conditionals" feature
+  # If you were using this setting previously, please use conditionals instead.
+  #
+  # If you need help converting your older 'match' setting to a conditional,
+  # I welcome you to join the #logstash irc channel on freenode or to email
+  # the logstash-users@googlegroups.com mailling list and ask for help! :)
+  config :match, :validate => :hash, :deprecated => true
+
+  # The fully-qualified email address to send the email to.
+  #
+  # This field also accepts a comma-separated string of addresses, for example: 
+  # "me@host.com, you@host.com"
+  #
+  # You can also use dynamic fields from the event with the %{fieldname} syntax.
+  config :to, :validate => :string, :required => true
+
+  # The fully-qualified email address for the From: field in the email.
+  config :from, :validate => :string, :default => "logstash.alert@nowhere.com"
+
+  # The fully qualified email address for the Reply-To: field.
+  config :replyto, :validate => :string
+
+  # The fully-qualified email address(es) to include as cc: address(es).
+  #
+  # This field also accepts a comma-separated string of addresses, for example: 
+  # "me@host.com, you@host.com"
+  config :cc, :validate => :string
+
+  # How Logstash should send the email, either via SMTP or by invoking sendmail.
+  config :via, :validate => :string, :default => "smtp"
+
+  # Specify the options to use:
+  #
+  # Via SMTP: smtpIporHost, port, domain, userName, password, authenticationType, starttls
+  #
+  # Via sendmail: location, arguments
+  #
+  # If you do not specify any `options`, you will get the following equivalent code set in
+  # every new mail object:
+  #
+  #     Mail.defaults do
+  #       delivery_method :smtp, { :smtpIporHost         => "localhost",
+  #                                :port                 => 25,
+  #                                :domain               => 'localhost.localdomain',
+  #                                :userName             => nil,
+  #                                :password             => nil,
+  #                                :authenticationType   => nil,(plain, login and cram_md5)
+  #                                :starttls             => true  }
+  #
+  #       retriever_method :pop3, { :address             => "localhost",
+  #                                 :port                => 995,
+  #                                 :user_name           => nil,
+  #                                 :password            => nil,
+  #                                 :enable_ssl          => true }
+  #
+  #       Mail.delivery_method.new  #=> Mail::SMTP instance
+  #       Mail.retriever_method.new #=> Mail::POP3 instance
+  #     end
+  #
+  # Each mail object inherits the defaults set in Mail.delivery_method. However, on
+  # a per email basis, you can override the method:
+  #
+  #     mail.delivery_method :sendmail
+  #
+  # Or you can override the method and pass in settings:
+  #
+  #     mail.delivery_method :sendmail, { :address => 'some.host' }
+  #
+  # You can also just modify the settings:
+  #
+  #     mail.delivery_settings = { :address => 'some.host' }
+  #
+  # The hash you supply is just merged against the defaults with "merge!" and the result
+  # assigned to the mail object.  For instance, the above example will change only the
+  # `:address` value of the global `smtp_settings` to be 'some.host', retaining all other values.
+  config :options, :validate => :hash, :default => {}
+
+  # Subject: for the email.
+  config :subject, :validate => :string, :default => ""
+
+  # Body for the email - plain text only.
+  config :body, :validate => :string, :default => ""
+
+  # HTML Body for the email, which may contain HTML markup.
+  config :htmlbody, :validate => :string, :default => ""
+
+  # Attachments - specify the name(s) and location(s) of the files.
+  config :attachments, :validate => :array, :default => []
+
+  # contenttype : for multipart messages, set the content-type and/or charset of the HTML part.
+  # NOTE: this may not be functional (KH)
+  config :contenttype, :validate => :string, :default => "text/html; charset=UTF-8"
+
+  public
+  def register
+    require "mail"
+
+    # Mail uses instance_eval which changes the scope of self so @options is
+    # inaccessible from inside 'Mail.defaults'. So set a local variable instead.
+    options = @options
+
+    if @via == "smtp"
+      Mail.defaults do
+        delivery_method :smtp, {
+          :address              => options.fetch("smtpIporHost", "localhost"),
+          :port                 => options.fetch("port", 25),
+          :domain               => options.fetch("domain", "localhost"),
+          :user_name            => options.fetch("userName", nil),
+          :password             => options.fetch("password", nil),
+          :authentication       => options.fetch("authenticationType", nil),
+          :enable_starttls_auto => options.fetch("starttls", false),
+          :debug                => options.fetch("debug", false)
+        }
+      end
+    elsif @via == 'sendmail'
+      Mail.defaults do
+        delivery_method :sendmail
+      end
+    else
+      Mail.defaults do
+        delivery_method :@via, options
+      end
+    end # @via tests
+    @logger.debug("Email Output Registered!", :config => @config)
+  end # def register
+
+  public
+  def receive(event)
+    return unless output?(event)
+      @logger.debug("Event being tested for Email", :tags => @tags, :event => event)
+      # Set Intersection - returns a new array with the items that are the same between the two
+      if !@tags.empty? && (event["tags"] & @tags).size == 0
+         # Skip events that have no tags in common with what we were configured
+         @logger.debug("No Tags match for Email Output!")
+         return
+      end
+
+    @logger.debug? && @logger.debug("Match data for Email - ", :match => @match)
+    successful = false
+    matchName = ""
+    operator = ""
+
+    # TODO(sissel): Delete this once match support is removed.
+    @match && @match.each do |name, query|
+      if successful
+        break
+      else
+        matchName = name
+      end
+      # now loop over the csv query
+      queryArray = query.split(',')
+      index = 1
+      while index < queryArray.length
+        field = queryArray.at(index -1)
+        value = queryArray.at(index)
+        index = index + 2
+        if field == ""
+          if value.downcase == "and"
+            operator = "and"
+          elsif value.downcase == "or"
+            operator = "or"
+          else
+            operator = "or"
+            @logger.error("Operator Provided Is Not Found, Currently We Only Support AND/OR Values! - defaulting to OR")
+          end
+        else
+          hasField = event[field]
+          @logger.debug? and @logger.debug("Does Event Contain Field - ", :hasField => hasField)
+          isValid = false
+          # if we have maching field and value is wildcard - we have a success
+          if hasField
+            if value == "*"
+              isValid = true
+            else
+              # we get an array so we need to loop over the values and find if we have a match
+              eventFieldValues = event[field]
+              @logger.debug? and @logger.debug("Event Field Values - ", :eventFieldValues => eventFieldValues)
+              eventFieldValues = [eventFieldValues] if not eventFieldValues.respond_to?(:each)
+              eventFieldValues.each do |eventFieldValue|
+                isValid = validateValue(eventFieldValue, value)
+                if isValid # no need to iterate any further
+                  @logger.debug("VALID CONDITION FOUND - ", :eventFieldValue => eventFieldValue, :value => value) 
+                  break
+                end
+              end # end eventFieldValues.each do
+            end # end value == "*"
+          end # end hasField
+          # if we have an AND operator and we have a successful == false break
+          if operator == "and" && !isValid
+            successful = false
+          elsif operator == "or" && (isValid || successful)
+            successful = true
+          else
+            successful = isValid
+          end
+        end
+      end
+    end # @match.each do
+
+    # The 'match' setting is deprecated and optional. If not set,
+    # default to success.
+    successful = true if @match.nil?
+
+    @logger.debug? && @logger.debug("Email Did we match any alerts for event : ", :successful => successful)
+
+    if successful
+      # first add our custom field - matchName - so we can use it in the sprintf function
+      event["matchName"] = matchName unless matchName.empty?
+      @logger.debug? and @logger.debug("Creating mail with these settings : ", :via => @via, :options => @options, :from => @from, :to => @to, :cc => @cc, :subject => @subject, :body => @body, :content_type => @contenttype, :htmlbody => @htmlbody, :attachments => @attachments, :to => to, :to => to)
+      formatedSubject = event.sprintf(@subject)
+      formattedBody = event.sprintf(@body)
+      formattedHtmlBody = event.sprintf(@htmlbody)
+      # we have a match(s) - send email
+      mail = Mail.new
+      mail.from = event.sprintf(@from)
+      mail.to = event.sprintf(@to)
+      if @replyto
+        mail.reply_to = event.sprintf(@replyto)
+      end
+      mail.cc = event.sprintf(@cc)
+      mail.subject = formatedSubject
+      if @htmlbody.empty?
+        formattedBody.gsub!(/\\n/, "\n") # Take new line in the email
+        mail.body = formattedBody
+      else
+        mail.text_part = Mail::Part.new do
+          content_type "text/plain; charset=UTF-8"
+          formattedBody.gsub!(/\\n/, "\n") # Take new line in the email
+          body formattedBody
+        end
+        mail.html_part = Mail::Part.new do
+          content_type "text/html; charset=UTF-8"
+          body formattedHtmlBody
+        end
+      end
+      @attachments.each do |fileLocation|
+        mail.add_file(fileLocation)
+      end # end @attachments.each
+      @logger.debug? and @logger.debug("Sending mail with these values : ", :from => mail.from, :to => mail.to, :cc => mail.cc, :subject => mail.subject)
+      mail.deliver!
+    end # end if successful
+  end # def receive
+
+
+  private
+  def validateValue(eventFieldValue, value)
+    valid = false
+    # order of this if-else is important - please don't change it
+    if value.start_with?(">=")# greater than or equal
+      value.gsub!(">=","")
+      if eventFieldValue.to_i >= value.to_i
+        valid = true
+      end
+    elsif value.start_with?("<=")# less than or equal
+      value.gsub!("<=","")
+      if eventFieldValue.to_i <= value.to_i
+        valid = true
+      end
+    elsif value.start_with?(">")# greater than
+      value.gsub!(">","")
+      if eventFieldValue.to_i > value.to_i
+        valid = true
+      end
+    elsif value.start_with?("<")# less than
+      value.gsub!("<","")
+      if eventFieldValue.to_i < value.to_i
+        valid = true
+      end
+    elsif value.start_with?("*")# contains
+      value.gsub!("*","")
+      if eventFieldValue.include?(value)
+        valid = true
+      end
+    elsif value.start_with?("!*")# does not contain
+      value.gsub!("!*","")
+      if !eventFieldValue.include?(value)
+        valid = true
+      end
+    elsif value.start_with?("!")# not equal
+      value.gsub!("!","")
+      if eventFieldValue != value
+        valid = true
+      end
+    else # default equal
+      if eventFieldValue == value
+        valid = true
+      end
+    end
+    return valid
+  end # end validateValue()
+
+end # class LogStash::Outputs::Email

data/logstash-output-email.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+
+  s.name            = 'logstash-output-email'
+  s.version         = '0.1.0'
+  s.licenses        = ['Apache License (2.0)']
+  s.summary         = "Send email when an output is received."
+  s.description     = "Send email when an output is received."
+  s.authors         = ["Elasticsearch"]
+  s.email           = 'richard.pijnenburg@elasticsearch.com'
+  s.homepage        = "http://logstash.net/"
+  s.require_paths = ["lib"]
+
+  # Files
+  s.files = `git ls-files`.split($\)+::Dir.glob('vendor/*')
+
+  # 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", "group" => "output" }
+
+  # Gem dependencies
+  s.add_runtime_dependency 'logstash', '>= 1.4.0', '< 2.0.0'
+
+  s.add_runtime_dependency 'mail'
+
+end
+

data/rakelib/publish.rake

@@ -0,0 +1,9 @@
+require "gem_publisher"
+
+desc "Publish gem to RubyGems.org"
+task :publish_gem do |t|
+  gem_file = Dir.glob(File.expand_path('../*.gemspec',File.dirname(__FILE__))).first
+  gem = GemPublisher.publish_if_updated(gem_file, :rubygems)
+  puts "Published #{gem}" if gem
+end
+

data/rakelib/vendor.rake

@@ -0,0 +1,169 @@
+require "net/http"
+require "uri"
+require "digest/sha1"
+
+def vendor(*args)
+  return File.join("vendor", *args)
+end
+
+directory "vendor/" => ["vendor"] do |task, args|
+  mkdir task.name
+end
+
+def fetch(url, sha1, output)
+
+  puts "Downloading #{url}"
+  actual_sha1 = download(url, output)
+
+  if actual_sha1 != sha1
+    fail "SHA1 does not match (expected '#{sha1}' but got '#{actual_sha1}')"
+  end
+end # def fetch
+
+def file_fetch(url, sha1)
+  filename = File.basename( URI(url).path )
+  output = "vendor/#{filename}"
+  task output => [ "vendor/" ] do
+    begin
+      actual_sha1 = file_sha1(output)
+      if actual_sha1 != sha1
+        fetch(url, sha1, output)
+      end
+    rescue Errno::ENOENT
+      fetch(url, sha1, output)
+    end
+  end.invoke
+
+  return output
+end
+
+def file_sha1(path)
+  digest = Digest::SHA1.new
+  fd = File.new(path, "r")
+  while true
+    begin
+      digest << fd.sysread(16384)
+    rescue EOFError
+      break
+    end
+  end
+  return digest.hexdigest
+ensure
+  fd.close if fd
+end
+
+def download(url, output)
+  uri = URI(url)
+  digest = Digest::SHA1.new
+  tmp = "#{output}.tmp"
+  Net::HTTP.start(uri.host, uri.port, :use_ssl => (uri.scheme == "https")) do |http|
+    request = Net::HTTP::Get.new(uri.path)
+    http.request(request) do |response|
+      fail "HTTP fetch failed for #{url}. #{response}" if [200, 301].include?(response.code)
+      size = (response["content-length"].to_i || -1).to_f
+      count = 0
+      File.open(tmp, "w") do |fd|
+        response.read_body do |chunk|
+          fd.write(chunk)
+          digest << chunk
+          if size > 0 && $stdout.tty?
+            count += chunk.bytesize
+            $stdout.write(sprintf("\r%0.2f%%", count/size * 100))
+          end
+        end
+      end
+      $stdout.write("\r      \r") if $stdout.tty?
+    end
+  end
+
+  File.rename(tmp, output)
+
+  return digest.hexdigest
+rescue SocketError => e
+  puts "Failure while downloading #{url}: #{e}"
+  raise
+ensure
+  File.unlink(tmp) if File.exist?(tmp)
+end # def download
+
+def untar(tarball, &block)
+  require "archive/tar/minitar"
+  tgz = Zlib::GzipReader.new(File.open(tarball))
+  # Pull out typesdb
+  tar = Archive::Tar::Minitar::Input.open(tgz)
+  tar.each do |entry|
+    path = block.call(entry)
+    next if path.nil?
+    parent = File.dirname(path)
+    
+    mkdir_p parent unless File.directory?(parent)
+
+    # Skip this file if the output file is the same size
+    if entry.directory?
+      mkdir path unless File.directory?(path)
+    else
+      entry_mode = entry.instance_eval { @mode } & 0777
+      if File.exists?(path)
+        stat = File.stat(path)
+        # TODO(sissel): Submit a patch to archive-tar-minitar upstream to
+        # expose headers in the entry.
+        entry_size = entry.instance_eval { @size }
+        # If file sizes are same, skip writing.
+        next if stat.size == entry_size && (stat.mode & 0777) == entry_mode
+      end
+      puts "Extracting #{entry.full_name} from #{tarball} #{entry_mode.to_s(8)}"
+      File.open(path, "w") do |fd|
+        # eof? check lets us skip empty files. Necessary because the API provided by
+        # Archive::Tar::Minitar::Reader::EntryStream only mostly acts like an
+        # IO object. Something about empty files in this EntryStream causes
+        # IO.copy_stream to throw "can't convert nil into String" on JRuby
+        # TODO(sissel): File a bug about this.
+        while !entry.eof?
+          chunk = entry.read(16384)
+          fd.write(chunk)
+        end
+          #IO.copy_stream(entry, fd)
+      end
+      File.chmod(entry_mode, path)
+    end
+  end
+  tar.close
+  File.unlink(tarball) if File.file?(tarball)
+end # def untar
+
+def ungz(file)
+
+  outpath = file.gsub('.gz', '')
+  tgz = Zlib::GzipReader.new(File.open(file))
+  begin
+    File.open(outpath, "w") do |out|
+      IO::copy_stream(tgz, out)
+    end
+    File.unlink(file)
+  rescue
+    File.unlink(outpath) if File.file?(outpath)
+   raise
+  end
+  tgz.close
+end
+
+desc "Process any vendor files required for this plugin"
+task "vendor" do |task, args|
+
+  @files.each do |file| 
+    download = file_fetch(file['url'], file['sha1'])
+    if download =~ /.tar.gz/
+      prefix = download.gsub('.tar.gz', '').gsub('vendor/', '')
+      untar(download) do |entry|
+        if !file['files'].nil?
+          next unless file['files'].include?(entry.full_name.gsub(prefix, ''))
+          out = entry.full_name.split("/").last
+        end
+        File.join('vendor', out)
+      end
+    elsif download =~ /.gz/
+      ungz(download)
+    end
+  end
+
+end

data/spec/outputs/email_spec.rb

@@ -0,0 +1,173 @@
+require "spec_helper"
+require "rumbster"
+require "message_observers"
+
+describe "outputs/email", :broken => true do
+    
+
+    @@port=2525
+    let (:rumbster) { Rumbster.new(@@port) }
+    let (:message_observer) { MailMessageObserver.new }
+
+    before :each do
+        rumbster.add_observer message_observer
+        rumbster.start
+    end
+
+    after :each do
+        rumbster.stop
+    end
+
+    describe  "use a list of email as mail.to (LOGSTASH-827)" do
+        config <<-CONFIG
+        input {
+            generator {
+                message => "hello world"
+                count => 1
+                type => "generator"
+            }
+        }
+        filter {
+            noop {
+                add_field => ["dummy_match", "ok"]
+            }
+        }
+        output{
+            email {
+                to => "email1@host, email2@host"
+                match => ["mymatch", "dummy_match,ok"]
+                options => ["port", #{@@port}]
+            }
+        }
+        CONFIG
+
+        agent do
+            insist {message_observer.messages.size} == 1
+            insist {message_observer.messages[0].to} == ["email1@host", "email2@host"]
+        end
+    end
+
+    describe  "use an array of email as mail.to (LOGSTASH-827)" do
+        config <<-CONFIG
+        input {
+            generator {
+                message => "hello world"
+                count => 1
+                type => "generator"
+            }
+        }
+        filter {
+            noop {
+                add_field => ["dummy_match", "ok"]
+                add_field => ["to_addr", "email1@host"]
+                add_field => ["to_addr", "email2@host"]
+            }
+        }
+        output{
+            email {
+                to => "%{to_addr}"
+                match => ["mymatch", "dummy_match,ok"]
+                options => ["port", #{@@port}]
+            }
+        }
+        CONFIG
+
+        agent do
+            insist {message_observer.messages.size} == 1
+            insist {message_observer.messages[0].to} == ["email1@host", "email2@host"]
+        end
+    end
+
+    describe  "multi-lined text body (LOGSTASH-841)" do
+        config <<-CONFIG
+        input {
+            generator {
+                message => "hello world"
+                count => 1
+                type => "generator"
+            }
+        }
+        filter {
+            noop {
+                add_field => ["dummy_match", "ok"]
+            }
+        }
+        output{
+            email {
+                to => "me@host"
+                subject => "Hello World"
+                body => "Line1\\nLine2\\nLine3"
+                match => ["mymatch", "dummy_match,*"]
+                options => ["port", #{@@port}]
+            }
+        }
+        CONFIG
+
+        agent do
+            insist {message_observer.messages.size} == 1
+            insist {message_observer.messages[0].subject} == "Hello World"
+            insist {message_observer.messages[0].body.raw_source} == "Line1\r\nLine2\r\nLine3"
+        end
+    end
+
+    describe  "use nil authenticationType (LOGSTASH-559)" do
+        config <<-CONFIG
+        input {
+            generator {
+                message => "hello world"
+                count => 1
+                type => "generator"
+            }
+        }
+        filter {
+            noop {
+                add_field => ["dummy_match", "ok"]
+            }
+        }
+        output{
+            email {
+                to => "me@host"
+                subject => "Hello World"
+                body => "Line1\\nLine2\\nLine3"
+                match => ["mymatch", "dummy_match,*"]
+                options => ["port", #{@@port}, "authenticationType", "nil"]
+            }
+        }
+        CONFIG
+
+        agent do
+            insist {message_observer.messages.size} == 1
+            insist {message_observer.messages[0].subject} == "Hello World"
+            insist {message_observer.messages[0].body.raw_source} == "Line1\r\nLine2\r\nLine3"
+        end
+    end
+
+    describe  "match on source and message (LOGSTASH-826)" do
+        config <<-CONFIG
+        input {
+            generator {
+                message => "hello world"
+                count => 1
+                type => "generator"
+            }
+        }
+        output{
+            email {
+                to => "me@host"
+                subject => "Hello World"
+                body => "Mail body"
+                match => ["messageAndSourceMatch", "message,*hello,,and,source,*generator"]
+                options => ["port", #{@@port}, "authenticationType", "nil"]
+            }
+        }
+        CONFIG
+
+        agent do
+            insist {message_observer.messages.size} == 1
+            insist {message_observer.messages[0].subject} == "Hello World"
+            insist {message_observer.messages[0].body.raw_source} == "Mail body"
+        end
+    end
+end
+
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: logstash-output-email
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Elasticsearch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logstash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Send email when an output is received.
+email: richard.pijnenburg@elasticsearch.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/logstash/outputs/email.rb
+- logstash-output-email.gemspec
+- rakelib/publish.rake
+- rakelib/vendor.rake
+- spec/outputs/email_spec.rb
+homepage: http://logstash.net/
+licenses:
+- Apache License (2.0)
+metadata:
+  logstash_plugin: 'true'
+  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.4.1
+signing_key: 
+specification_version: 4
+summary: Send email when an output is received.
+test_files:
+- spec/outputs/email_spec.rb