rack-access-capture 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8911f1418898cc356642bffbe5b174629cd546c0
+  data.tar.gz: 2125d9a0db9613d0a2afcbe56a50bba311e5cb2f
+SHA512:
+  metadata.gz: 973e5287ae69c3ef18be156caf7da4fbe49c95dee8b4b11058da91a22b54ec3230791743fd93e0a0a5de1ad074cf02bca1dbf6da2af3fd8553dcfd9bd7244e07
+  data.tar.gz: 03d054e1e7ecdb9236bb448560bd2a6ffaeb1bddd2fa8a698df70656b6407a0f46d86a4eccaafecb2ae26896432fb05bc70ed366b96e7c669aeb10b7479fd20a

data/lib/rack/access/capture/collector/abstract_adapter.rb

@@ -0,0 +1,20 @@
+module Rack
+  module Access
+    module Capture
+      module Collector
+
+        class AbstractAdapter
+
+          def collect?(env)
+            false
+          end
+
+          # This is meant to be implemented by the adapters that support access log collect.
+          def collect
+            # this should be overridden by concrete adapters
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/access/capture/collector/adapters.rb

@@ -0,0 +1,61 @@
+require 'rack/access/capture/collector/console_adapter'
+require 'rack/access/capture/collector/fluentd_adapter'
+
+module Rack
+  module Access
+    module Capture
+      module Collector
+
+        class Adapters
+
+          BUILTIN_ADAPTERS = [:console, :fluentd].freeze
+          COLLECTOR_ADAPTER_METHODS = ["collect?", "collect"].freeze
+          SUFFIX_CLASS_NAME = "Adapter".freeze
+
+          private_constant :BUILTIN_ADAPTERS, :COLLECTOR_ADAPTER_METHODS, :SUFFIX_CLASS_NAME
+
+          class << self
+
+            def interpret_collector(config)
+              name_or_class = config["adapter"] if !config.nil? && config.is_a?(Hash) && config.key?("adapter")
+              case name_or_class
+              when Symbol
+                collector_class = lookup(name_or_class)
+                collector_class.nil? ? lookup(:console).new : collector_class.new(config["config"])
+              when String
+                console_adapter_in_case_of_name_error do
+                  builtin_klass = lookup(name_or_class)
+                  obj = builtin_klass.nil? ? Object.const_get(name_or_class).new(config["config"]) : builtin_klass.new(config["config"])
+                  collector_adapter?(obj) ? obj : lookup(:console).new
+                end
+              else
+                lookup(:console).new
+              end
+            end
+
+            private
+
+            def collector_adapter?(object)
+              COLLECTOR_ADAPTER_METHODS.all? { |method_name| object.respond_to?(method_name) }
+            end
+
+            def lookup(name)
+              return nil unless BUILTIN_ADAPTERS.include? name.to_sym
+              const_get("Rack::Access::Capture::Collector::#{name.capitalize}#{SUFFIX_CLASS_NAME}")
+            end
+
+            def console_adapter_in_case_of_name_error(&block)
+              proc {
+                begin
+                  yield
+                rescue NameError
+                  lookup(:console).new
+                end
+              }.call
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/access/capture/collector/console_adapter.rb

@@ -0,0 +1,25 @@
+require 'json'
+require "rack/access/capture/collector/abstract_adapter"
+
+module Rack
+  module Access
+    module Capture
+      module Collector
+
+        class ConsoleAdapter < AbstractAdapter
+
+          def initialize(config = {})
+          end
+
+          def collect?(env)
+            true
+          end
+
+          def collect(log)
+            $stdout.puts log.to_json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/access/capture/collector/fluentd_adapter.rb

@@ -0,0 +1,60 @@
+require 'fluent-logger'
+require "rack/access/capture/collector/abstract_adapter"
+
+module Rack
+  module Access
+    module Capture
+      module Collector
+
+        class FluentdAdapter < AbstractAdapter
+
+          attr_reader :tag
+
+          def initialize(options = {})
+            config = options || {}
+            @tag = config["tag"] || 'development'
+            tag_prefix = config["tag_prefix"]
+            host = config["host"] || 'localhost'
+            port = config["port"] || 24224
+            handler = proc { |messages| BufferOverflowHandler.new(config["log_file_path"]).flush(messages) }
+            buffer_limit = config["buffer_limit"] || 131072 # Buffer limit of the standard is 128.kilobyte
+            log_reconnect_error_threshold = config["log_reconnect_error_threshold"] || Fluent::Logger::FluentLogger::RECONNECT_WAIT_MAX_COUNT
+            options = { host: host,
+                        port: port,
+                        buffer_limit: buffer_limit,
+                        buffer_overflow_handler: handler,
+                        log_reconnect_error_threshold: log_reconnect_error_threshold }
+            @logger = config["logger"] || Fluent::Logger::FluentLogger.new(tag_prefix, options)
+            exclude_request = config["exclude_request"] || []
+            @collect = [GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, LINK, UNLINK, TRACE] - exclude_request
+          end
+
+          def collect?(env)
+            @collect.include?(env["REQUEST_METHOD"])
+          end
+
+          def collect(log)
+            @logger.post(@tag, log)
+          end
+        end
+
+        class BufferOverflowHandler
+
+          def initialize(log_dirirectory_path)
+            @log_directory_path = log_dirirectory_path
+          end
+
+          def flush(messages)
+            return if @log_directory_path.nil?
+
+            MessagePack::Unpacker.new.feed_each(messages) do |msg|
+              open("#{@log_directory_path}/#{msg[0]}_#{msg[1]}.json", 'w') do |io|
+                JSON.dump(msg[2], io)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/access/capture/config.rb

@@ -0,0 +1,70 @@
+require 'rack/access/capture/collector/adapters'
+require 'rack/access/capture/watcher/adapters'
+require 'rack/access/capture/watcher/internal_watcher_adapter'
+
+module Rack
+  module Access
+    module Capture
+      class Config
+
+        attr_reader :_collector, :_watcher, :_internal_watcher
+
+        class << self
+          def config_accessor(*names)
+            names.each do |name|
+              class_eval <<-METHOD
+                def #{name}
+                  @#{name}
+                end
+
+                def #{name}=(value)
+                  @#{name} = value
+                  if "#{name}" == "filter"
+                    @_internal_watcher = Rack::Access::Capture::Watcher::InternalWatcherAdapter.new(convert_hash(value))
+                  else
+                    @_#{name} = Object.const_get("Rack::Access::Capture::#{name.capitalize}::Adapters").send("interpret_#{name}", convert_hash(value))
+                  end
+                end
+              METHOD
+            end
+          end
+
+          private :config_accessor
+        end
+
+        config_accessor :collector, :watcher, :filter
+
+        def initialize(config = {})
+          convertd_config = convert_hash(config)
+
+          self.collector = convertd_config["collector"] if convertd_config.key?("collector")
+          self.watcher = convertd_config["watcher"] if convertd_config.key?("watcher")
+          self.filter = convertd_config["filter"]
+        end
+
+        private
+
+        def convert_hash(hash)
+          return {} if hash.nil?
+          return hash unless hash.is_a?(Hash)
+
+          converted_hash = {}
+
+          hash.each do |key, value|
+            key = key.to_s if key.is_a?(Symbol)
+
+            if value.is_a?(Hash)
+              value = convert_hash(value)
+            elsif value.is_a?(Array)
+              value = value.map { |v| v.is_a?(Hash) ? convert_hash(v) : v }
+            end
+
+            converted_hash[key] = value
+          end
+
+          converted_hash
+        end
+      end
+    end
+  end
+end

data/lib/rack/access/capture/manager.rb

@@ -0,0 +1,50 @@
+require 'rack/access/capture/config'
+
+module Rack
+  module Access
+    module Capture
+      class Manager
+
+        attr_accessor :config
+
+        def initialize(app, options = {})
+          @app = app
+          @config = Rack::Access::Capture::Config.new(options)
+          yield @config if block_given?
+        end
+
+        def call(env)
+          captured_request = @config._watcher.nil? ? {} : @config._watcher.request_capture(env)
+          status_code, header, body = @app.call(env)
+          captured_response = @config._watcher.nil? ? {} : @config._watcher.response_capture(env, status_code, header)
+
+          if !@config._collector.nil? && @config._collector.collect?(env)
+            access_log = @config._internal_watcher.access_log(env, status_code, header)
+            captured_access_log = merge_logs(captured_request, captured_response, access_log)
+            @config._collector.collect(captured_access_log)
+          end
+
+          [status_code, header, body]
+        end
+
+        private
+
+        def merge_logs(captured_request, captured_response, access_log = {})
+          if captured_request && captured_request.is_a?(Hash)
+            access_log.merge!(captured_request)
+          else
+            access_log.merge!(request: captured_request.to_s) unless captured_request.nil?
+          end
+
+          if captured_response && captured_response.is_a?(Hash)
+            access_log.merge!(captured_response)
+          else
+            access_log.merge!(response: captured_response.to_s) unless captured_response.nil?
+          end
+
+          access_log
+        end
+      end
+    end
+  end
+end

data/lib/rack/access/capture/version.rb

@@ -0,0 +1,7 @@
+module Rack
+  module Access
+    module Capture
+      VERSION = "0.0.1".freeze
+    end
+  end
+end

data/lib/rack/access/capture/watcher/adapters.rb

@@ -0,0 +1,44 @@
+module Rack
+  module Access
+    module Capture
+      module Watcher
+
+        class Adapters
+
+          WATCHER_ADAPTER_METHODS = %w(request_capture response_capture).freeze
+
+          private_constant :WATCHER_ADAPTER_METHODS
+
+          class << self
+            def interpret_watcher(config)
+              class_name = config["adapter"] if !config.nil? && config.is_a?(Hash) && config.key?("adapter")
+
+              if class_name.is_a?(String)
+                with_ignoring_name_error do
+                  object = Object.const_get(class_name).new
+                  watcher_adapter?(object) ? object : nil
+                end
+              end
+            end
+
+            private
+
+            def watcher_adapter?(object)
+              WATCHER_ADAPTER_METHODS.all? { |method_name| object.respond_to?(method_name) }
+            end
+
+            def with_ignoring_name_error(&block)
+              proc {
+                begin
+                  yield
+                rescue NameError
+                  nil
+                end
+              }.call
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/access/capture/watcher/base_adapter.rb

@@ -0,0 +1,18 @@
+module Rack
+  module Access
+    module Capture
+      module Watcher
+        class BaseAdapter
+
+          def request_capture(env)
+            # this should be overridden by concrete adapters
+          end
+
+          def response_capture(env, http_status_code, header)
+            # this should be overridden by concrete adapters
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/access/capture/watcher/internal_watcher_adapter.rb

@@ -0,0 +1,68 @@
+require 'woothee'
+require 'rack/access/capture/watcher/base_adapter'
+
+module Rack
+  module Access
+    module Capture
+      module Watcher
+        class InternalWatcherAdapter < BaseAdapter
+
+          attr_reader :filter_params
+
+          def initialize(config = {})
+            params = config.is_a?(Hash) && config.key?("params") ? config["params"] : []
+            @filter_params = initialize_filter_params(params)
+          end
+
+          def access_log(env, status_code, header)
+            request = Rack::Request.new(env)
+            log = {}
+            log["status"] = status_code
+            log["path"] = request.path
+            log["method"] = request.request_method
+            log["params"] = params_filter(request.params).to_s
+            ua = Woothee.parse(request.user_agent)
+            log["device"] = ua[:category]
+            log["os"] = ua[:os]
+            log["browser"] = ua[:name]
+            log["browser_ver"] = ua[:version]
+            log["user_agent"] = request.user_agent
+            log["remote_ip"] = request.ip
+            access_time = Time.now.to_i
+            log["time"] = access_time
+            log["accessed_at"] = access_time
+            log
+          end
+
+          private
+
+          def initialize_filter_params(filter_items)
+            filter_strings = []
+            filter_strings << Rack::Access::Capture::DEFAULT_FILTER_PARAMS
+            filter_strings << filter_items.map(&:to_s)
+            filter_strings.flatten!.uniq
+            filter_strings.map { |item| Regexp.compile(Regexp.escape(item.to_s)) }
+          end
+
+          def params_filter(params)
+            filtered_params = {}
+
+            params.each do |key, value|
+              if @filter_params.any? { |filter| key =~ filter }
+                value = Rack::Access::Capture::FILTERED
+              elsif value.is_a?(Hash)
+                value = params_filter(value)
+              elsif value.is_a?(Array)
+                value = value.map { |v| v.is_a?(Hash) ? params_filter(v) : v }
+              end
+
+              filtered_params[key] = value
+            end
+
+            filtered_params
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/access/capture.rb

@@ -0,0 +1,26 @@
+require "rack/access/capture/version"
+require "rack/access/capture/config"
+require "rack/access/capture/manager"
+require "rack/access/capture/collector/abstract_adapter"
+require "rack/access/capture/watcher/base_adapter"
+
+module Rack
+  module Access
+    module Capture
+      # parameter filter
+      FILTERED = '[FILTERED]'.freeze
+      DEFAULT_FILTER_PARAMS = %w(password authenticity_token).freeze
+      # HTTP method
+      GET     = 'GET'.freeze
+      POST    = 'POST'.freeze
+      PUT     = 'PUT'.freeze
+      PATCH   = 'PATCH'.freeze
+      DELETE  = 'DELETE'.freeze
+      HEAD    = 'HEAD'.freeze
+      OPTIONS = 'OPTIONS'.freeze
+      LINK    = 'LINK'.freeze
+      UNLINK  = 'UNLINK'.freeze
+      TRACE   = 'TRACE'.freeze
+    end
+  end
+end

data/lib/rack-access-capture.rb

@@ -0,0 +1 @@
+require 'rack/access/capture'

data/rack-access-capture.gemspec

@@ -0,0 +1,30 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack/access/capture/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rack-access-capture'
+  spec.version       = Rack::Access::Capture::VERSION
+  spec.authors       = ['moonstruckdrops']
+  spec.email         = ['moonstruckdrops@gmail.com']
+
+  spec.summary       = 'To capture the request and response in the rack middleware, you can be output to any destination.'
+  spec.description   = 'To capture the request and response in the rack middleware, you can be output to any destination.'
+  spec.homepage      = 'https://github.com/livesense-inc/rack-access-capture'
+  spec.license       = 'MIT'
+
+  spec.files         = ['rack-access-capture.gemspec'].concat(Dir.glob('lib/**/*').reject { |f| File.directory?(f) || f =~ /~$/ })
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '~> 2.0'
+
+  spec.add_dependency 'woothee', '~> 1.4'
+  spec.add_dependency 'fluent-logger', '~> 0.5.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.4.0'
+  spec.add_development_dependency 'rack-test', '~> 0.6.3'
+  spec.add_development_dependency 'rubocop', '~> 0.40.0'
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: rack-access-capture
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- moonstruckdrops
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: woothee
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: fluent-logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.40.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.40.0
+description: To capture the request and response in the rack middleware, you can be
+  output to any destination.
+email:
+- moonstruckdrops@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack-access-capture.rb
+- lib/rack/access/capture.rb
+- lib/rack/access/capture/collector/abstract_adapter.rb
+- lib/rack/access/capture/collector/adapters.rb
+- lib/rack/access/capture/collector/console_adapter.rb
+- lib/rack/access/capture/collector/fluentd_adapter.rb
+- lib/rack/access/capture/config.rb
+- lib/rack/access/capture/manager.rb
+- lib/rack/access/capture/version.rb
+- lib/rack/access/capture/watcher/adapters.rb
+- lib/rack/access/capture/watcher/base_adapter.rb
+- lib/rack/access/capture/watcher/internal_watcher_adapter.rb
+- rack-access-capture.gemspec
+homepage: https://github.com/livesense-inc/rack-access-capture
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: To capture the request and response in the rack middleware, you can be output
+  to any destination.
+test_files: []