active_endpoint 0.2.0

data/lib/active_endpoint/routes/constraint_rule.rb

@@ -0,0 +1,38 @@
+module ActiveEndpoint
+  module Routes
+    class ConstraintRule
+      include Optionable
+      include Constraintable
+
+      def initialize(request)
+        @request = request
+        @rules = ActiveEndpoint.constraints
+      end
+
+      def rule
+        {
+          key: "#{prefix}:#{@request[:endpoint]}"
+        }.merge(fetch_constraints)
+      end
+
+      private
+
+      def prefix
+        return :endpoints if @rules.present_endpoint?(@request)
+        return :resources if @rules.present_resource?(@request)
+        return :actions if @rules.present_action?(@request)
+        return :scopes if @rules.present_scope?(@request)
+        :defaults
+      end
+
+      def fetch_constraints
+        if prefix == :defaults
+          default_constraints
+        else
+          constraints = @rules.public_send(prefix)[@request[:endpoint]]
+          constraints.present? ? constraints : default_constraints
+        end
+      end
+    end
+  end
+end

data/lib/active_endpoint/routes/constraints.rb

@@ -0,0 +1,81 @@
+module ActiveEndpoint
+  module Routes
+    class Constraints < Momento
+      include Constraintable
+
+      def initialize
+        super(Hash)
+      end
+
+      def add(options)
+        super(options) do |options|
+          if fetch_rule(options).nil?
+            message = "Constraints can't have empty limit and period!\n"
+            raise ActiveEndpoint::Routes::Constraints::Error.new(message)
+          end
+        end
+      end
+
+      def present_endpoint?(request)
+        @endpoints.keys.include?(request[:endpoint])
+      end
+
+      def present_resource?(request)
+        reduce_state(@resources.keys, request)
+      end
+
+      def present_action?(request)
+        @actions.keys.include?(request[:endpoint])
+      end
+
+      def present_scope?(request)
+        reduce_state(@scopes.keys, request)
+      end
+
+      private
+
+      def add_endpoint(options)
+        @endpoints[fetch_endpoint(options)] = constraints(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}"] = constraints(options) }
+            end
+          else
+            actions.each { |action| temp_actions["#{resources}##{action}"] = constraints(options) }
+          end
+          @actions = @actions.merge(apply(scope, temp_actions))
+        else
+          temp_resources = {}
+          if resources.is_a?(Array)
+            resources.each { |resource| temp_resources[resource] = constraints(options) }
+          else
+            temp_resources[resources] = constraints(options)
+          end
+          @resources = @resources.merge(apply(scope, temp_resources))
+        end
+      end
+
+      def add_scopes(options)
+        @scopes[fetch_scope(options)] = constraints(options)
+      end
+
+      def apply(scope, collection)
+        return collection unless scope.present?
+
+        collection.inject({}) do |hash, (key, value)|
+          hash["#{scope}/#{key}"] = value
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/active_endpoint/routes/matcher.rb

@@ -0,0 +1,51 @@
+module ActiveEndpoint
+  module Routes
+    class Matcher
+      include RailsRoutable
+
+      def initialize
+        @blacklist = ActiveEndpoint.blacklist
+        @cache_store = ActiveEndpoint::Routes::Cache::Store.new
+      end
+
+      def whitelisted?(request)
+        trackable?(request) && rails_action?(request)
+      end
+
+      def blacklisted?(probe)
+        @blacklist.include?(probe)
+      end
+
+      def unregistred?(request)
+        trackable?(request) && !rails_action(request)
+      end
+
+      def assets?(request)
+        request.path.start_with?('/assets')
+      end
+
+      def allow_account?(request)
+        @constraint_rule = ActiveEndpoint::Routes::ConstraintRule.new(request).rule
+        @cache_store.allow?(@constraint_rule)
+      end
+
+      def allow_register?(request)
+        @cache_store.unregistred?(request.probe)
+      end
+
+      private
+
+      def favicon?(request)
+        request.path == '/favicon.ico'
+      end
+
+      def engine?(request)
+        request.path.include?('active_endpoint')
+      end
+
+      def trackable?(request)
+        !(engine?(request) || assets?(request) || favicon?(request) || blacklisted?(request.probe))
+      end
+    end
+  end
+end

data/lib/active_endpoint/routes/momento.rb

@@ -0,0 +1,81 @@
+module ActiveEndpoint
+  module Routes
+    class Momento
+      include Configurable
+      include Optionable
+
+      class Error < ::StandardError; end
+
+      attr_reader :endpoints, :resources, :actions, :scopes
+
+      def initialize(structure_class)
+        @endpoints = structure_class.new
+        @resources = structure_class.new
+        @actions = structure_class.new
+        @scopes = structure_class.new
+      end
+
+      def include?(request)
+        any_presented? [
+          present_endpoint?(request),
+          present_resource?(request),
+          present_action?(request),
+          present_scope?(request)
+        ]
+      end
+
+      def add(**options, &block)
+
+        yield(options) if block_given?
+
+        add_endpoint(options) if fetch_endpoint(options).present?
+        add_resources(options) if fetch_resources(options).present?
+        add_scopes(options) if fetch_scope(options).present?
+      end
+
+      private
+
+      def add_endpoint(_options)
+        raise NotImplementedError
+      end
+
+      def add_resource(_options)
+        raise NotImplementedError
+      end
+
+      def add_scopes(_options)
+        raise NotImplementedError
+      end
+
+      def present_endpoint?(_request)
+        raise NotImplementedError
+      end
+
+      def present_resource?(_request)
+        raise NotImplementedError
+      end
+
+      def present_action?(_request)
+        raise NotImplementedError
+      end
+
+      def present_scope?(_request)
+        raise NotImplementedError
+      end
+
+      def apply(_scope, _collection)
+        raise NotImplementedError
+      end
+
+      def any_presented?(chain)
+        chain.reduce(false) { |state, responder_state| state || responder_state }
+      end
+
+      def reduce_state(collection, request)
+        collection.reduce(false) do |state, subject|
+          state || request[:endpoint].present? && request[:endpoint].start_with?(subject)
+        end
+      end
+    end
+  end
+end

data/lib/active_endpoint/storage.rb

@@ -0,0 +1,112 @@
+module ActiveEndpoint
+  class Storage
+    STORING_FIELDS = [
+      :body,
+      :response,
+      :started_at,
+      :finished_at,
+      :duration,
+      :endpoint,
+      :ip,
+      :params,
+      :path,
+      :request_method,
+      :url,
+      :xhr
+    ].freeze
+
+    LOGGING_FIELDS = [
+      :base_url,
+      :content_charset,
+      :content_length,
+      :content_type,
+      :fullpath,
+      :http_version,
+      :http_connection,
+      :http_accept_encoding,
+      :http_accept_language,
+      :media_type,
+      :media_type_params,
+      :method,
+      :path_info,
+      :pattern,
+      :port,
+      :protocol,
+      :server_name,
+      :ssl
+    ].freeze
+
+    class << self
+      def notifier
+        ActiveSupport::Notifications
+      end
+
+      def probe_params(transaction_id, probe)
+        request = probe.delete(:request)
+        request_body = request.delete(:body)
+
+        response = probe.delete(:response)
+        response_body = response.present? ? response[:body] : nil
+
+        params = {
+          uuid: transaction_id,
+          response: response_body ? Base64.encode64(response_body) : '',
+          started_at: probe[:created_at],
+          finished_at: probe[:finished_at],
+          duration: probe[:finished_at] ? (probe[:finished_at] - probe[:created_at]).second.round(3) : 0,
+          body: request_body.is_a?(Puma::NullIO) ? '' : request_body
+        }.merge(request)
+
+        [params.dup.except(*LOGGING_FIELDS), params.dup.except(*STORING_FIELDS)]
+      end
+
+      def store!(params)
+        handle_creation(ActiveEndpoint::Probe.new(params))
+      end
+
+      def register!(params)
+        handle_creation(ActiveEndpoint::UnregistredProbe.new(params.merge(endpoint: :unregistred)))
+      end
+
+      def handle_creation(probe)
+        probe.save
+      rescue => error
+        ActiveEndpoint.logger.error('ActiveEndpoint::Probe', error)
+      end
+
+      def clean!(endpoint, period)
+        ActiveEndpoint::Probe.registred.probe(endpoint).taken_before(period).destroy_all
+      end
+    end
+
+    notifier.subscribe('active_endpoint.tracked_probe') do |_name, _start, _ending, id, payload|
+      store_params, logging_params = probe_params(id, payload[:probe])
+
+      ActiveEndpoint.logger.info('ActiveEndpoint::Storage', logging_params, ActiveEndpoint.log_probe_info)
+
+      store!(store_params)
+    end
+
+    notifier.subscribe('active_endpoint.unregistred_probe') do |_name, _start, _ending, id, payload|
+      store_params, logging_params = probe_params(id, payload[:probe])
+
+      if ActiveEndpoint.log_debug_info
+        ActiveEndpoint.logger.debug('ActiveEndpoint::Storage', store_params.inspect)
+        ActiveEndpoint.logger.debug('ActiveEndpoint::Storage', logging_params.inspect)
+      end
+
+      register!(store_params)
+    end
+
+    notifier.subscribe('active_endpoint.clean_expired') do |_name, _start, _ending, id, payload|
+      key = payload[:expired][:key].split(':').last
+      period = DateTime.now - (payload[:expired][:period] * ActiveEndpoint.storage_keep_periods).seconds
+
+      if ActiveEndpoint.log_debug_info
+        ActiveEndpoint.logger.info('ActiveEndpoint::Storage', { key: key, period: period, uuid: id }.inspect)
+      end
+
+      clean!(key, period)
+    end
+  end
+end

data/lib/active_endpoint/tags.rb

@@ -0,0 +1,15 @@
+module ActiveEndpoint
+  class Tags
+    include Configurable
+
+    attr_reader :definition
+
+    def initialize
+      @definition = {}
+    end
+
+    def add(tag, condition)
+      @definition[tag] = condition
+    end
+  end
+end

data/lib/active_endpoint/version.rb

@@ -0,0 +1,3 @@
+module ActiveEndpoint
+  VERSION = '0.2.0'.freeze
+end

data/lib/generators/active_endpoint/install_generator.rb

@@ -0,0 +1,35 @@
+module ActiveEndpoint
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration
+
+      source_root File.expand_path('../templates', __dir__)
+
+      class << self
+        def next_migration_number(_dirname)
+          Time.current.strftime('%Y%m%d%H%M%S')
+        end
+      end
+
+      puts '=> Creates a ActiveEndpoint initializer, migration and migrate data base for your application.'
+
+      def copy_initializer_file
+        puts '=> Copy initializer file to config/initializers/active_endpoint.rb'
+        copy_file 'active_endpoint.rb', 'config/initializers/active_endpoint.rb'
+      end
+
+      def copy_migration_file
+        puts '=> Create migration file in db/migrate/***_create_active_endpoint_probes.rb'
+        migration_template 'migration.erb', 'db/migrate/create_active_endpoint_probes.rb',
+                           migration_version: migration_version
+      end
+
+      private
+
+      def migration_version
+        last_rails = ::Rails.version.start_with?('5')
+        "[#{::Rails::VERSION::MAJOR}.#{::Rails::VERSION::MINOR}]" if last_rails
+      end
+    end
+  end
+end

data/lib/generators/templates/active_endpoint.rb

@@ -0,0 +1,40 @@
+ActiveEndpoint.configure do |endpoint|
+  endpoint.blacklist.configure do |list|
+    # list.add(endpoint: 'web/welcome#index')
+    # list.add(resources: 'web/users', actions: ['show'])
+    # list.add(scope: 'web', resources: 'users', actions: ['show'])
+    # list.add(scope: 'web')
+  end
+
+  endpoint.constraint_limit = 100
+  endpoint.constraint_period = 1.minute
+
+  endpoint.storage_limit = 1000
+  endpoint.storage_period = 1.day
+  endpoint.storage_keep_periods = 2
+
+  endpoint.constraints.configure do |constraints|
+    # constraints.add(endpoint: 'web/welcome#index',
+    #   rule: { limit: 100, period: 1.minute },
+    #   storage: { limit: 1000, period: 1.week }
+    # })
+    # constraints.add(scope: 'web', resources: 'users', rule: { limit: 100 })
+    # constraints.add(scope: 'web', resources: ['users'],
+    #   actions: [:show, :edit, :update],
+    #   rule: { limit: 10, period: 1.minute })
+    # constraints.add(scope: 'web', rule: { limit: 100, period: 1.minute })
+  end
+
+  endpoint.tags.configure do |tags|
+    # tags.add(:fast, { less_than: 250 })
+    # tags.add(:normal, { greater_than_or_equal_to: 250, less_than: 500 })
+    # tags.add(:slow, { greater_than_or_equal_to: 250, less_than: 500 })
+    # tags.add(:acceptable, { greater_than_or_equal_to: 500, less_than: 100 })
+    # tags.add(:need_optimization, { greater_than_or_equal_to: 1000 })
+  end
+
+  define_setting :logger, ActiveEndpoint::Logger
+
+  define_setting :log_probe_info, false
+  define_setting :log_debug_info, false
+end