fluent-plugin-sentry-http 0.1.0

data/.gitignore

@@ -0,0 +1,14 @@
+.bundle
+.yardoc
+Gemfile.lock
+_yardoc
+coverage
+doc
+pkg
+spec/reports
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fluent-plugin-sentry-http.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright (c) 2015- IKUTA Masahito
+
+   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/README.md

@@ -0,0 +1,45 @@
+# fluent-plugin-sentry-http
+
+[fluentd](http://fluentd.org) input plugin that receive exceptions from [Sentry Clients](https://github.com/getsentry).
+
+[![Build Status](https://travis-ci.org/cooldaemon/fluent-plugin-sentry-http.svg?branch=master)](https://travis-ci.org/cooldaemon/fluent-plugin-sentry-http)
+
+## Installation
+
+Install with gem or fluent-gem command as:
+
+```
+# for fluentd
+$ gem install fluent-plugin-sentry-http
+
+# for td-agent
+$ sudo /usr/lib64/fluent/ruby/bin/fluent-gem install fluent-plugin-sentry-http
+```
+
+## Component
+
+### SentryHttpInput
+
+Plugin to accept exception input from [Sentry Clients](https://github.com/getsentry).
+
+#### Configuration
+
+```
+<source>
+  type sentry_http
+  port 8888
+  bind 0.0.0.0
+  <application 999>
+    tag sentry.egg
+    user aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    pass bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+  </application>
+</source>
+```
+
+## Copyright
+
+- Copyright
+  - Copyright(C) 2015- IKUTA Masahito (cooldaemon)
+- License
+  - Apache License, Version 2.0

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/fluent-plugin-sentry-http.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fluent/plugin/sentry_http/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fluent-plugin-sentry-http"
+  spec.version       = Fluent::Plugin::SentryHttp::VERSION
+  spec.authors       = ["IKUTA Masahito"]
+  spec.email         = ["cooldaemon@gmail.com"]
+  spec.summary       = %q{Fluentd input plugin that receive exceptions from the Sentry clients(Raven).}
+  spec.description   = spec.summary
+  spec.homepage      = "http://github.com/cooldaemon/fluent-plugin-sentry-http"
+  spec.license       = "APLv2"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "test-unit", ["~> 3.0", "~> 3.1"]
+
+  spec.add_dependency "fluentd", ">= 0.10.55"
+  spec.add_dependency "oj", ">= 1.4"
+end

data/lib/fluent/plugin/in_sentry_http.rb

@@ -0,0 +1,103 @@
+require 'fluent/plugin/in_http'
+
+module Fluent
+  class SentryHttpInput < HttpInput
+    Plugin.register_input('sentry_http', self)
+
+    config_param :format, :string, :default => 'sentry_http'
+
+    attr_reader :mapping
+
+    def initialize
+      super
+      @mapping = {}
+    end
+
+    def configure(conf)
+      super
+      conf.elements.select {|element|
+        element.name == 'application'
+      }.each do |element|
+        @mapping[element.arg] = {
+          'tag' => element['tag'],
+          'user' => element['user'],
+          'pass' => element['pass'],
+        }
+      end
+    end
+
+    def on_request(path_info, params)
+      begin
+        application = @mapping[path_info.split('/')[2]]  # /api/999/store/
+        raise 'not found' unless application
+      rescue
+        return ['404 Not Found', {'Content-type' => 'text/plain'}, '']
+      end
+
+      begin
+        user, pass = get_auth_info(params)
+        raise 'unauthorized' unless application['user'] == user and application['pass'] == pass
+      rescue
+        return ['401 Unauthorized', {'Content-type' => 'text/plain'}, '']
+      end
+
+      begin
+        time, record = parse_params(params)
+        raise 'Record not found' if record.nil?
+
+        record['tag'] = application['tag']
+        record['time'] = time
+
+        if @add_http_headers
+          params.each_pair { |k, v|
+            if k.start_with?('HTTP_')
+              record[k] = v
+            end
+          }
+        end
+
+        if @add_remote_addr
+          record['REMOTE_ADDR'] = params['REMOTE_ADDR']
+        end
+      rescue
+        return ['400 Bad Request', {'Content-type' => 'text/plain'}, "400 Bad Request\n#{$!}\n"]
+      end
+
+      begin
+        router.emit(application['tag'], time, record)
+      rescue
+        return ['500 Internal Server Error', {'Content-type' => 'text/plain'}, "500 Internal Server Error\n#{$!}\n"]
+      end
+
+      return ['200 OK', {'Content-type' => 'text/plain'}, '']
+    end 
+
+    private
+
+    def parse_params_with_parser(params)
+      if content = params[EVENT_RECORD_PARAMETER]
+          @parser.parse(content) { |time, record|
+            raise "Received event is not #{@format}: #{content}" if record.nil?
+            return time, record
+          }
+      else
+        raise "'#{EVENT_RECORD_PARAMETER}' parameter is required"
+      end
+    end
+
+    def get_auth_info(params)
+      user = nil
+      pass = nil
+      params['HTTP_X_SENTRY_AUTH'].split(', ').each do |element|
+        key, value = element.split('=')
+        case key
+        when 'sentry_key'
+          user = value
+        when 'sentry_secret'
+          pass = value
+        end
+      end
+      return user, pass
+    end
+  end
+end

data/lib/fluent/plugin/parser_sentry_http.rb

@@ -0,0 +1,37 @@
+require 'base64'
+require 'zlib'
+require 'oj'
+
+module Fluent
+  class TextParser
+    class SentryHttpParser < Parser
+      Plugin.register_parser('sentry_http', self)
+
+      config_param :json_parse, :bool, :default => true
+      config_param :field_name, :string, :default => 'message'
+
+      def initialize
+        super
+      end
+ 
+      def configure(conf)
+        super
+      end
+
+      def parse(text)
+        message = Zlib::Inflate.inflate(Base64.decode64(text))
+        record = Oj.load(message, :mode => :compat)
+
+        record_time = record['timestamp']
+        time = record_time.nil? ? Engine.now : Time.parse(record_time).to_i
+
+        record = {@field_name => message} unless @json_parse
+
+        yield time, record
+      rescue => e
+        $log.warn "parse error: #{e.message}"
+        yield nil, nil
+      end
+    end
+  end
+end

data/lib/fluent/plugin/sentry_http/version.rb

@@ -0,0 +1,7 @@
+module Fluent
+  module Plugin
+    module SentryHttp
+      VERSION = '0.1.0'
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'fileutils'
+require 'fluent/log'
+require 'fluent/test'
+
+$log = Fluent::Log.new(STDOUT, Fluent::Log::LEVEL_DEBUG)
+
+unless defined?(Test::Unit::AssertionFailedError)
+  class Test::Unit::AssertionFailedError < StandardError
+  end
+end
+
+def unused_port
+  s = TCPServer.open(0)
+  port = s.addr[1]
+  s.close
+  port
+end
+
+def ipv6_enabled?
+  require 'socket'
+
+  begin
+    TCPServer.open("::1", 0)
+    true
+  rescue
+    false
+  end
+end
+
+require 'fluent/plugin/in_sentry_http'
+require 'fluent/plugin/parser_sentry_http'
+
+class Test::Unit::TestCase
+end

data/test/plugin/test_in_sentry_http.rb

@@ -0,0 +1,137 @@
+require 'helper'
+require 'net/http'
+require 'base64'
+require 'zlib'
+require 'oj'
+
+class SentryHttpInputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  PORT = unused_port
+  HOST = '127.0.0.1'
+  APPLICATION = 999
+  TAG = 'from.raven'
+  USER = 'test_user'
+  PASS = 'test_pass'
+
+  CONFIG = %[
+    port #{PORT}
+    bind #{HOST}
+
+    <application #{APPLICATION}>
+      tag #{TAG}
+      user #{USER}
+      pass #{PASS}
+    </application>
+  ]
+
+  def create_driver(conf=CONFIG)
+    Fluent::Test::InputTestDriver.new(Fluent::SentryHttpInput).configure(conf)
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal PORT, d.instance.port
+    assert_equal '127.0.0.1', d.instance.bind
+
+    application = d.instance.mapping[APPLICATION.to_s]
+    assert_equal TAG, application['tag']
+    assert_equal USER, application['user']
+    assert_equal PASS, application['pass']
+  end
+
+  def test_success_request
+    time, record, expect_record = create_time_and_record
+    d = create_driver
+    d.expect_emit TAG, time, expect_record
+    d.run do
+      res = post_record(
+        APPLICATION,
+        create_headers(time, USER, PASS),
+        record_to_payload(record))
+      assert_equal '200', res.code
+    end
+  end
+
+  def test_not_found_request
+    time, record, expect_record = create_time_and_record
+    d = create_driver
+    d.run do
+      res = post_record(
+        998,
+        create_headers(time, USER, PASS),
+        record_to_payload(record))
+      assert_equal '404', res.code
+    end
+  end
+
+  def test_unauthorized_request
+    time, record, expect_record = create_time_and_record
+    d = create_driver
+    d.run do
+      res = post_record(
+        APPLICATION,
+        create_headers(time, 'ham', PASS),
+        record_to_payload(record))
+      assert_equal '401', res.code
+
+      res = post_record(
+        APPLICATION,
+        create_headers(time, USER, 'egg'),
+        record_to_payload(record))
+      assert_equal '401', res.code
+    end
+  end
+
+  def test_bad_request
+    time, record, expect_record = create_time_and_record
+    d = create_driver
+    d.run do
+      res = post_record(
+        APPLICATION,
+        create_headers(time, USER, PASS),
+        'spam')
+      assert_equal '400', res.code
+    end
+  end
+
+  private
+
+  def create_time_and_record
+    timestamp = '2015-07-26T09:24:30Z'
+    time = Time.parse(timestamp).to_i
+    record = create_record(timestamp)
+    expect_record = record.merge({'tag' => TAG, 'time' => time})
+    return time, record, expect_record
+  end
+
+  def create_headers(time, user, pass)
+    {
+      'X-Sentry-Auth' => "Sentry sentry_timestamp=#{time}, sentry_client=raven-python/5.2.0, sentry_version=6, sentry_key=#{user}, sentry_secret=#{pass}",
+      'Content-Type' => 'application/octet-stream',
+      'User-Agent' => 'raven-python/5.2.0',
+    }
+  end
+
+  def create_record(timestamp)
+    {
+      'timestamp' => timestamp,
+      'message' => 'test',
+    }
+  end
+
+  def record_to_payload(record)
+    text = Oj.dump(record, :mode => :compat)
+    compressed_text = Zlib::Deflate.deflate(text)
+    Base64.encode64(compressed_text)
+  end
+
+  def post_record(application, headers, payload)
+    http = Net::HTTP.new(HOST, PORT)
+    req = Net::HTTP::Post.new("/api/#{application}/store/", headers)
+    req.body = payload
+    http.request(req)
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: fluent-plugin-sentry-http
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- IKUTA Masahito
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2015-07-26 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rake
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 10
+        - 0
+        version: "10.0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: test-unit
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 1
+        version: "3.1"
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  name: fluentd
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 55
+        version: 0.10.55
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  name: oj
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        version: "1.4"
+  requirement: *id004
+description: Fluentd input plugin that receive exceptions from the Sentry clients(Raven).
+email: 
+- cooldaemon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- fluent-plugin-sentry-http.gemspec
+- lib/fluent/plugin/in_sentry_http.rb
+- lib/fluent/plugin/parser_sentry_http.rb
+- lib/fluent/plugin/sentry_http/version.rb
+- test/helper.rb
+- test/plugin/test_in_sentry_http.rb
+has_rdoc: true
+homepage: http://github.com/cooldaemon/fluent-plugin-sentry-http
+licenses: 
+- APLv2
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Fluentd input plugin that receive exceptions from the Sentry clients(Raven).
+test_files: 
+- test/helper.rb
+- test/plugin/test_in_sentry_http.rb