active_endpoint 0.2.0

data/lib/active_endpoint/engine.rb

@@ -0,0 +1,15 @@
+module ActiveEndpoint
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveEndpoint
+
+    initializer 'active_endpoint.assets.precompile' do |app|
+      app.config.assets.precompile += %w()
+    end
+
+    config.generators do |g|
+      g.orm :active_record
+      g.template_engine :erb
+      g.test_framework  :rspec
+    end
+  end
+end

data/lib/active_endpoint/extentions/active_record.rb

@@ -0,0 +1,30 @@
+module ActiveEndpoint
+  module Extentions
+    module ActiveRecord
+      METHODS = {
+        greater_than: '>',
+        greater_than_or_equal_to: '>=',
+        equal_to: '=',
+        less_than: '<',
+        less_than_or_equal_to: '<='
+      }.freeze
+
+      def tagged_as(tag, tags = ActiveEndpoint.tags.definition)
+        return [] unless tags.keys.include?(tag)
+
+        time_operators = tags[tag]
+        last_operator_index = time_operators.keys.length - 1
+
+        query = ''
+        time_operators.each_with_index do |(key, value), index|
+          operator = METHODS[key]
+          duration = (value.to_f / 1000).to_s
+          and_operator = last_operator_index == index ? '' : ' AND '
+          query << 'duration ' + operator + ' ' + duration + ' ' + and_operator
+        end
+
+        where(query)
+      end
+    end
+  end
+end

data/lib/active_endpoint/logger.rb

@@ -0,0 +1,28 @@
+module ActiveEndpoint
+  class Logger
+    class << self
+      def info(caller, info, force = nil)
+        return if force.nil? || !force
+        logger.info(message(caller, info))
+      end
+
+      def debug(caller, message)
+        logger.debug(message(caller, message))
+      end
+
+      def error(caller, error)
+        logger.error(message(caller, error))
+      end
+
+      private
+
+      def logger
+        ::Rails.logger
+      end
+
+      def message(caller, message)
+        "ActiveEndpoint::Logger [#{caller}] - #{message}"
+      end
+    end
+  end
+end

data/lib/active_endpoint/proxy.rb

@@ -0,0 +1,64 @@
+module ActiveEndpoint
+  class Proxy
+    def initialize
+      @created_at = Time.now
+      @matcher = ActiveEndpoint::Routes::Matcher.new
+      @logger = ActiveEndpoint.logger
+      @notifier = ActiveSupport::Notifications
+    end
+
+    def track(env, &block)
+      request = ActiveEndpoint::Request.new(env)
+
+      if ActiveEndpoint.log_debug_info
+        @logger.debug('ActiveEndpoint::Blacklist', ActiveEndpoint.blacklist.inspect)
+        @logger.debug('ActiveEndpoint::Constraints', ActiveEndpoint.constraints.inspect)
+      end
+
+      if @matcher.whitelisted?(request)
+        track_begin(request)
+        status, headers, response = yield block
+        track_end(response)
+        [status, headers, response]
+      else
+        register(request) if @matcher.unregistred?(request)
+
+        yield block
+      end
+    rescue => error
+      @logger.error(self.class, error)
+
+      yield block
+    end
+
+    private
+
+    def track_begin(request)
+      @request = request.probe
+    end
+
+    def track_end(response, finished_at = Time.now)
+      @response = ActiveEndpoint::Response.new(response).probe
+      @finished_at = finished_at
+
+      probe = {
+        created_at: @created_at,
+        finished_at: @finished_at,
+        request: @request,
+        response: @response
+      }
+
+      @notifier.instrument('active_endpoint.tracked_probe', probe: probe) if @matcher.allow_account?(@request)
+    end
+
+    def register(request)
+      unregistred = {
+        created_at: @created_at,
+        finished_at: @finished_at,
+        request: request.probe
+      }
+
+      @notifier.instrument('active_endpoint.unregistred_probe', probe: unregistred) if @matcher.allow_register?(request)
+    end
+  end
+end

data/lib/active_endpoint/rails/middleware.rb

@@ -0,0 +1,17 @@
+module ActiveEndpoint
+  module Rails
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        dup._call(env, ActiveEndpoint::Proxy.new)
+      end
+
+      def _call(env, proxy)
+        proxy.track(env) { @app.call(env) }
+      end
+    end
+  end
+end

data/lib/active_endpoint/rails/railtie.rb

@@ -0,0 +1,13 @@
+module ActiveEndpoint
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer 'active_endpoint.configure_rails_initialization' do |app|
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::Base.send(:extend, ::ActiveEndpoint::Extentions::ActiveRecord)
+        end
+
+        app.middleware.insert(0, ActiveEndpoint::Rails::Middleware)
+      end
+    end
+  end
+end

data/lib/active_endpoint/request.rb

@@ -0,0 +1,79 @@
+module ActiveEndpoint
+  class Request < Rack::Request
+    include RailsRoutable
+
+    def probe
+      {
+        base_url: base_url,
+        body: body,
+        content_charset: content_charset,
+        content_length: content_length,
+        content_type: content_type,
+        endpoint: endpoint,
+        fullpath: fullpath,
+        http_version: http_version,
+        http_connection: http_connection,
+        http_accept_encoding: http_accept_encoding,
+        http_accept_language: http_accept_language,
+        ip: ip,
+        media_type: media_type,
+        media_type_params: media_type_params,
+        method: method,
+        params: params,
+        path: path,
+        path_info: path_info,
+        pattern: pattern,
+        port: port,
+        protocol: protocol,
+        query_string: query_string,
+        request_method: request_method,
+        server_name: server_name,
+        ssl: ssl?,
+        url: url,
+        xhr: xhr?
+      }
+    end
+
+    def method
+      request_method.downcase.to_sym
+    end
+
+    def endpoint
+      rails_endpoint_name(rails_endpoint(self))
+    end
+
+    private
+
+    def http_accept_encoding
+      get_header('HTTP_ACCEPT_ENCODING')
+    end
+
+    def http_accept_language
+      get_header('HTTP_ACCEPT_LANGUAGE')
+    end
+
+    def http_connection
+      get_header('HTTP_CONNECTION')
+    end
+
+    def http_version
+      get_header('HTTP_VERSION')
+    end
+
+    def params
+      rails_request_params(self)
+    end
+
+    def pattern
+      rails_route_pattern(self)
+    end
+
+    def protocol
+      get_header('SERVER_PROTOCOL')
+    end
+
+    def server_name
+      get_header('SERVER_NAME')
+    end
+  end
+end

data/lib/active_endpoint/response.rb

@@ -0,0 +1,17 @@
+module ActiveEndpoint
+  class Response
+    def initialize(response)
+      @response = response
+    end
+
+    def probe
+      {
+        body: body
+      }
+    end
+
+    def body
+      @response.join if @response.respond_to? :join
+    end
+  end
+end

data/lib/active_endpoint/routes/blacklist.rb

@@ -0,0 +1,67 @@
+module ActiveEndpoint
+  module Routes
+    class Blacklist < Momento
+      def initialize
+        super(Array)
+      end
+
+      private
+
+      def add_endpoint(options)
+        @endpoints << fetch_endpoint(options)
+      end
+
+      def add_resources(options)
+        resources = fetch_resources(options)
+        actions = fetch_actions(options)
+        scope = fetch_scope(options)
+
+        if actions.present? && actions.any?
+          temp_actions = []
+          if resources.is_a?(Array)
+            resources.each do |controller_name|
+              actions.each { |action| temp_actions << "#{controller_name}##{action}" }
+            end
+          else
+            actions.each { |action| temp_actions << "#{resources}##{action}" }
+          end
+          @actions += apply(scope, temp_actions)
+        else
+          temp_resources = []
+          if resources.is_a?(Array)
+            resources.each { |resource| temp_resources << resource }
+          else
+            temp_resources << resources
+          end
+          @resources += apply(scope, temp_resources)
+        end
+      end
+
+      def add_scopes(options)
+        scope = fetch_scope(options)
+        @scopes << scope unless @scopes.include?(scope)
+      end
+
+      def present_endpoint?(request)
+        @endpoints.include?(request[:endpoint])
+      end
+
+      def present_resource?(request)
+        reduce_state(@resources, request)
+      end
+
+      def present_action?(request)
+        @actions.include?(request[:endpoint])
+      end
+
+      def present_scope?(request)
+        reduce_state(@scopes, request)
+      end
+
+      def apply(scope, collection)
+        return collection unless scope.present?
+        collection.map { |subject| "#{scope}/#{subject}" }
+      end
+    end
+  end
+end

data/lib/active_endpoint/routes/cache/proxy.rb

@@ -0,0 +1,22 @@
+module ActiveEndpoint
+  module Routes
+    module Cache
+      module Proxy
+        class AdapterError < ::StandardError; end
+
+        CLIENTS = {
+          redis: 'RedisStoreProxy'
+        }.freeze
+
+        def self.build(adapter)
+          unless CLIENTS.keys.include?(adapter)
+            message "You try to use unsupported cache store adapter! #{adapter}\n"
+            raise ActiveEndpoint::Routes::Cache::Proxy::AdapterError.new(message)
+          end
+
+          "ActiveEndpoint::Routes::Cache::Proxy::#{CLIENTS[adapter]}".constantize.new
+        end
+      end
+    end
+  end
+end

data/lib/active_endpoint/routes/cache/proxy/redis_store_proxy.rb

@@ -0,0 +1,41 @@
+module ActiveEndpoint
+  module Routes
+    module Cache
+      module Proxy
+        class RedisStoreProxy
+          def initialize
+            @prefix = ActiveEndpoint.cache_prefix
+            @store = ::Redis::Store.new
+          end
+
+          def read(unprefixed_key)
+            @store.get("#{@prefix}:#{unprefixed_key}")
+          end
+
+          def write(unprefixed_key, value, expires_in = nil)
+            store_key = store_key(unprefixed_key)
+
+            if expires_in.present?
+              @store.setex(store_key, expires_in, value)
+            else
+              @store.set(store_key, value)
+            end
+
+            true
+          end
+
+          def expires_in(unprefixed_key)
+            time = @store.ttl(store_key(unprefixed_key)).to_i
+            time == -1 || time == -2 ? 0 : time
+          end
+
+          private
+
+          def store_key(unprefixed_key)
+            "#{@prefix}:#{unprefixed_key}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_endpoint/routes/cache/store.rb

@@ -0,0 +1,73 @@
+module ActiveEndpoint
+  module Routes
+    module Cache
+      class Store
+        delegate :read, to: :@store
+        delegate :write, to: :@store
+        delegate :expires_in, to: :@store
+
+        def initialize
+          @store = ActiveEndpoint::Routes::Cache::Proxy.build(ActiveEndpoint.cache_store_client)
+          @logger = ActiveEndpoint.logger
+          @notifier = ActiveSupport::Notifications
+        end
+
+        def allow?(rule)
+          rule_cache_allow?(rule) && storage_cache_allow?(rule)
+        end
+
+        def unregistred?(probe)
+          path = probe[:path]
+          read(path).present? ? false : write(path, :unregistred)
+        end
+
+        private
+
+        def rule_cache_allow?(options)
+          cache_allow?(:rule, options)
+        end
+
+        def storage_cache_allow?(options)
+          cache_allow?(:storage, options) do |key, period|
+            expired = {
+              key: key,
+              period: period
+            }
+
+            @notifier.instrument('active_endpoint.clean_expired', expired: expired)
+          end
+        end
+
+        def cache_allow?(prefix, options, &block)
+
+          key = "#{prefix}:#{options[:key]}"
+          constraints = options[prefix]
+
+          cache = read(key)
+          limit = cache.nil? ? cache : cache.to_i
+          period = expires_in(key)
+
+          if ActiveEndpoint.log_debug_info
+            @logger.debug('ActiveEndpoint::Cache::Store Prefix', prefix)
+            @logger.debug('ActiveEndpoint::Cache::Store Limit', limit)
+            @logger.debug('ActiveEndpoint::Cache::Store Period', period)
+          end
+
+          limited = limit.present? && limit.zero?
+          expired = period.zero?
+
+          if limit.nil? && expired && block_given?
+            yield(options[:key], constraints[:period])
+          end
+
+          if limit.present? && !expired
+            return false if limited
+            write(key, limit - 1, period)
+          else
+            write(key, constraints[:limit] - 1, constraints[:period])
+          end
+        end
+      end
+    end
+  end
+end