delfos 0.0.1.pre.rc1 → 0.0.1

data/lib/delfos/method_logging/call_site_parsing.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require "binding_of_caller"
+
+module Delfos
+  module MethodLogging
+    class CallSiteParsing
+      # This magic number is based on the implementation within this file.
+      # If the line with `call_site_binding.of_caller(stack_index + STACK_OFFSET).receiver`
+      # is moved up or down the call stack a test fails and we have to change `STACK_OFFSET`
+      STACK_OFFSET = 5
+
+      attr_reader :stack, :call_site_binding
+
+      def initialize(stack, call_site_binding, stack_offset: nil)
+        @stack             = stack
+        @call_site_binding = call_site_binding
+        @stack_offset      = stack_offset
+      end
+
+      def perform
+        file, line_number, method_name = method_details
+        return unless current && file && line_number && method_name
+
+        CodeLocation.new(object: object,
+                         method_name: method_name.to_s,
+                         class_method: class_method,
+                         file: file,
+                         line_number: line_number)
+      end
+
+      private
+
+      def class_method
+        object.is_a? Module
+      end
+
+      def current
+        stack.detect do |s|
+          file = s.split(":")[0]
+          Delfos::MethodLogging.include_file?(file)
+        end
+      end
+
+      def object
+        @object ||= call_site_binding.of_caller(stack_index + stack_offset).receiver
+      end
+
+      def stack_offset
+        @stack_offset ||= STACK_OFFSET
+      end
+
+      def stack_index
+        stack.index { |c| c == current }
+      end
+
+      METHOD_NAME_REGEX = /`(.*)'$/
+
+      def method_details
+        return unless current
+        file, line_number, rest, more = current.split(":")
+
+        rest = more.nil? ?  rest : "#{rest}:#{more}"
+        method_name = rest.match(METHOD_NAME_REGEX)&.[](1)
+
+        return unless method_name && file && line_number
+
+        method_name = method_name.delete("`")
+        method_name = method_name.delete("'")
+
+        [file, line_number.to_i, method_name]
+      end
+    end
+  end
+end

data/lib/delfos/method_logging/code_location.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require_relative "call_site_parsing"
 
 module Delfos
   module MethodLogging
@@ -12,141 +13,76 @@ module Delfos
           file, line_number = called_method.source_location
           return unless file && line_number
 
-          new(object, called_method.name.to_s, class_method, file, line_number)
+          new(object: object, method_name: called_method.name.to_s,
+              class_method: class_method, file: file, line_number: line_number)
         end
 
-        def method_type_from(class_method)
-          class_method ? "ClassMethod" : "InstanceMethod"
-        end
       end
 
-      attr_reader :object, :method_name, :class_method, :method_type, :file, :line_number
+      attr_reader :object, :method_name, :class_method, :line_number
 
-      def initialize(object, method_name, class_method, file, line_number)
-        @object = object
-        @method_name = method_name
+      def initialize(object:, method_name:, class_method:, file:, line_number:)
+        @object       = object
+        @method_name  = method_name
         @class_method = class_method
-        @method_type = self.class.method_type_from class_method
-        @line_number = line_number.to_i
-        @file = file
+        @line_number  = line_number.to_i
+        @file         = file
       end
 
       def file
-        file = @file.to_s
-
-        if file
-          Delfos.application_directories.map do |d|
-            file = relative_path(file, d)
-          end
-        end
-
-        file
-      end
-
-      def relative_path(file, dir)
-        match = dir.to_s.split("/")[0..-2].join("/")
-
-        if file[match]
-          file = file.gsub(match, "").
-                 gsub(%r{^/}, "")
-        end
-
-        file
+        relative_filename @file
       end
 
       def klass
         object.is_a?(Class) ? object : object.class
       end
 
-      def klass_name
-        name = klass.name || "__AnonymousClass"
-        name.tr ":", "_"
-      end
-
       def method_definition_file
-        if method_definition
-          method_definition[0].to_s
-        else
-          #TODO fix edge case when block
-          "#{@file} in block"
-        end
+        relative_filename(method_definition&.first || fallback_method_definition_file)
       end
 
       def method_definition_line
-        if method_definition
-          method_definition[1].to_i
-        else
-          #TODO fix edge case when block
-          0
-        end
-      end
-
-      private
-
-      def method_key
-        "#{method_type}_#{method_name}"
+        method_definition&.last&.to_i || fallback_method_definition_line_number
       end
 
-      def method_definition
-        @method_definition ||= ::Delfos::MethodLogging::AddedMethods.method_source_for(klass, method_key)
+      def method_type
+        class_method ? "ClassMethod" : "InstanceMethod"
       end
-    end
 
-    class CallSiteParsing
-      # This magic number is based on the implementation within this file.
-      # If the line with `call_site_binding.of_caller(stack_index + STACK_OFFSET).receiver`
-      # is moved up or down the call stack a test fails and we have to change `STACK_OFFSET`
-      STACK_OFFSET = 5
+      private
 
-      attr_reader :stack, :call_site_binding
+      def relative_filename(f)
+        return unless f
+        file = f.to_s
 
-      def initialize(stack, call_site_binding, stack_offset: nil)
-        @stack = stack
-        @call_site_binding = call_site_binding
-        @stack_offset = stack_offset
-      end
-
-      def perform
-        file, line_number, method_name = method_details
-        return unless current && file && line_number && method_name
+        Delfos.application_directories.map do |d|
+          file = relative_path(file, d)
+        end
 
-        CodeLocation.new(object, method_name.to_s, class_method, file, line_number)
+        file
       end
 
-      private
-
-      def class_method
-        object.is_a? Module
-      end
+      def relative_path(file, dir)
+        match = dir.to_s.split("/")[0..-2].join("/")
 
-      def current
-        stack.detect do |s|
-          file = s.split(":")[0]
-          Delfos.method_logging.include_file_in_logging?(file)
+        if file[match]
+          file = file.gsub(match, "").
+                 gsub(%r{^/}, "")
         end
-      end
 
-      def object
-        @object ||= call_site_binding.of_caller(stack_index + stack_offset).receiver
+        file
       end
 
-      def stack_offset
-        @stack_offset ||= STACK_OFFSET
+      def fallback_method_definition_file
+        @file
       end
 
-      def stack_index
-        stack.index { |c| c == current }
+      def fallback_method_definition_line_number
+        0
       end
 
-      def method_details
-        return unless current
-        file, line_number, rest = current.split(":")
-        method_name = rest[/`.*'$/]
-        return unless method_name && file && line_number
-
-        method_name.delete!("`").delete!("'")
-
-        [file, line_number.to_i, method_name]
+      def method_definition
+        @method_definition ||= Patching::MethodCache.find(klass: klass, method_name: method_name, class_method: class_method)&.source_location
       end
     end
   end

data/lib/delfos/method_logging/{args.rb → method_parameters.rb}

@@ -1,27 +1,33 @@
 # frozen_string_literal: true
-require_relative "../../delfos"
-require_relative "../common_path"
-require_relative "./added_methods"
+require "delfos/patching/method_cache"
 
 module Delfos
   module MethodLogging
-    class Args
+    class MethodParameters
       attr_reader :block
 
-      def initialize(arguments)
-        @raw_args = arguments.args
-        @raw_keyword_args = arguments.keyword_args
-        @block = arguments.block
+      def initialize(args=[], keyword_args=nil, block=nil)
+        @raw_args         = args
+        @raw_keyword_args = keyword_args
+        @block            = block
       end
 
       def args
         @args ||= calculate_args(@raw_args)
       end
 
+      def argument_classes
+        (args + keyword_args).uniq
+      end
+
       def keyword_args
         @keyword_args ||= calculate_args(@raw_keyword_args.values)
       end
 
+      def as_json(*params)
+        {arguments: args, keyword_arguments: keyword_args}
+      end
+
       private
 
       def calculate_args(arguments)
@@ -32,22 +38,15 @@ module Delfos
 
       def keep?(klass)
         files_for(klass).
-          select { |f| record?(f) }.length.positive?
+          any? { |f| record?(f) }
       end
 
       def files_for(klass)
-        source_files(klass).
-          flatten.
-          compact.
-          uniq
-      end
-
-      def source_files(klass)
-        AddedMethods.all_method_sources_for(klass).map(&:first)
+        Patching::MethodCache.files_for(klass)
       end
 
       def record?(f)
-        Delfos.method_logging.include_any_path_in_logging?(f)
+        Delfos::MethodLogging.include_file?(f)
       end
     end
   end

data/lib/delfos/neo4j.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require_relative "neo4j/informer"
+require_relative "neo4j/query_execution/sync"
+require_relative "neo4j/batch/execution"
+require_relative "neo4j/schema"
+require_relative "neo4j/distance/update"
+
+module Delfos
+  module Neo4j
+    extend self
+
+    def execute_sync(query, params = {})
+      QueryExecution::Sync.new(query, params).perform
+    end
+
+    def execute(query, params = {})
+      Batch::Execution.execute!(query, params: params)
+    end
+
+    def flush!
+      Batch::Execution.flush!
+    end
+
+    def ensure_schema!
+      Schema.ensure_constraints!(
+        "Class"     => "name",
+        "CallStack" => "number",
+      )
+    end
+
+    def update_distance!
+      Distance::Update.new.perform
+    end
+
+    def config
+      host     ||= ENV["NEO4J_HOST"]     || "http://localhost"
+      port     ||= ENV["NEO4J_PORT"]     || "7476"
+      username ||= ENV["NEO4J_USERNAME"] || "neo4j"
+      password ||= ENV["NEO4J_PASSWORD"] || "password"
+
+      Neo4jConfig.new(host, port, username, password)
+    end
+
+    Neo4jConfig = Struct.new(:host, :port, :username, :password) do
+      def url
+        "#{host}:#{port}"
+      end
+
+      def uri_for(path)
+        URI.parse("#{url}#{path}")
+      end
+
+      def to_s
+        "  host: #{host}\n  port: #{port}\n  username: #{username}\n  password: #{password}"
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/batch/execution.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require "delfos/neo4j/query_execution/transactional"
+
+module Delfos
+  module Neo4j
+    module Batch
+      class Execution
+        BATCH_MUTEX = Mutex.new
+
+        class << self
+          def execute!(query, params: {}, size: nil)
+            batch = @batch || new_batch(size || 1_000)
+
+            batch.execute!(query, params: params)
+          end
+
+          def new_batch(size)
+            @batch = new(size: size)
+          end
+
+          def flush!
+            @batch&.flush!
+          rescue
+            reset!
+          end
+
+          def reset!
+            @batch = nil
+          end
+
+          attr_writer :batch
+        end
+
+        def initialize(size:, clock: Time)
+          @size                    = size
+          @clock                   = clock
+          @queries                 = []
+          @expires                 = nil
+          @commit_url              = nil
+          @current_transaction_url = nil
+        end
+
+        attr_reader :size, :current_transaction_url, :commit_url, :expires, :queries
+
+        def execute!(query, params: {}, retrying: false)
+          queries.push([query, params]) unless retrying
+
+          with_retry(retrying) do
+            BATCH_MUTEX.synchronize do
+              check_for_expiry!
+
+              perform_query(query, params)
+              flush_if_required!
+            end
+          end
+        end
+
+        def flush!
+          return unless query_count.positive?
+          return unless @commit_url
+          QueryExecution::Transactional.flush!(@commit_url)
+
+          reset!
+        end
+
+        def query_count
+          queries.length
+        end
+
+        private
+
+        def perform_query(query, params)
+          transactional_query = QueryExecution::Transactional.new(query, params, url)
+          transaction_url, @commit_url, @expires = transactional_query.perform
+          @current_transaction_url ||= transaction_url # the transaction_url is only returned with the first request
+        end
+
+        def with_retry(retrying)
+          yield
+        rescue QueryExecution::ExpiredTransaction
+          @retry_count ||= 0
+
+          if retrying
+            @retry_count += 1
+
+            if @retry_count > 5
+              @retry_count = 0
+              raise
+            end
+          end
+
+          Delfos.logger.error "Transaction expired - retrying batch. #{query_count} queries retry_count: #{@retry_count}"
+          reset_transaction!
+          retry_batch!
+        end
+
+        def retry_batch!
+          queries.each do |q, p|
+            execute!(q, params: p, retrying: true)
+          end
+        end
+
+        def url
+          return @commit_url if @commit_url && batch_full? || expires_soon?
+
+          current_transaction_url || new_transaction_url
+        end
+
+        def new_transaction_url
+          Delfos.neo4j.uri_for("/db/data/transaction")
+        end
+
+        def check_for_expiry!
+          return unless @expires
+
+          if @clock.now > @expires
+            self.class.batch = nil
+            raise QueryExecution::ExpiredTransaction.new(@comit_url, "")
+          end
+        end
+
+        def flush_if_required!
+          check_for_expiry!
+
+          flush! if batch_full? || expires_soon?
+        end
+
+        def batch_full?
+          query_count >= size
+        end
+
+        def expires_soon?
+          @expires && (@clock.now + 2 > @expires)
+        end
+
+        def reset!
+          @queries = []
+          reset_transaction!
+        end
+
+        def reset_transaction!
+          @current_transaction_url = nil
+          @commit_url = nil
+          @expires = nil
+        end
+      end
+    end
+  end
+end