delfos 0.0.1 → 0.0.2.pre.rc2

data/lib/delfos/method_trace/call_handler.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "delfos/call_stack"
+require_relative "code_location"
+require_relative "code_location/filename_helpers"
+
+module Delfos
+  module MethodTrace
+    CallHandler = Struct.new(:trace_point)
+
+    class CallHandler
+      include CodeLocation::FilenameHelpers
+
+      def perform
+        return unless relevant?
+
+        CallStack.push(call_site)
+      end
+
+      def call_site
+        @call_site ||= CodeLocation.callsite_from(
+          container_method: container_method,
+          called_method:    called_method,
+        )
+      end
+
+      def container_method
+        @container_method ||= CodeLocation.create_container_method
+      end
+
+      def called_method
+        @called_method ||= CodeLocation.method_from(
+          object:       trace_point.self,
+          method_name:  trace_point.method_id,
+          file:         trace_point.path,
+          line_number:  trace_point.lineno,
+          class_method: trace_point.self.is_a?(Module),
+        )
+      end
+
+      private
+
+      def relevant?
+        Delfos.include_file?(call_site.called_method_path)
+      end
+    end
+  end
+end

data/lib/delfos/method_trace/code_location.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "code_location/method"
+require_relative "code_location/call_site"
+require_relative "code_location/container_method_factory"
+require_relative "code_location/eval_in_caller"
+
+module Delfos
+  module MethodTrace
+    module CodeLocation
+      class << self
+        include EvalInCaller
+
+        def method_from(attrs)
+          Method.new(attrs)
+        end
+
+        STACK_OFFSET = 8
+
+        def callsite_from(container_method:, called_method:, stack_offset: STACK_OFFSET)
+          CallSite.new(
+            container_method: container_method,
+            called_method:    called_method,
+            file:             eval_in_caller("__FILE__", stack_offset),
+            line_number:      eval_in_caller("__LINE__", stack_offset),
+          )
+        end
+
+        def create_container_method
+          ContainerMethodFactory.create
+        end
+      end
+    end
+  end
+end

data/lib/delfos/method_trace/code_location/call_site.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "filename_helpers"
+
+module Delfos
+  module MethodTrace
+    module CodeLocation
+      class CallSite
+        include FilenameHelpers
+        attr_reader :line_number, :container_method, :called_method
+
+        def initialize(file:, line_number:, container_method:, called_method:)
+          @file             = file
+          @line_number      = line_number.to_i
+
+          @container_method = container_method
+          @called_method    = called_method
+        end
+
+        def container_method_path
+          container_method.raw_path
+        end
+
+        def called_method_path
+          called_method.raw_path
+        end
+
+        def summary
+          {
+            call_site: "#{file}:#{line_number}",
+            container_method: container_method.summary,
+            called_method:    called_method.summary,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/delfos/method_trace/code_location/container_method_factory.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "eval_in_caller"
+require_relative "filename_helpers"
+
+module Delfos
+  module MethodTrace
+    module CodeLocation
+      class ContainerMethodFactory
+        include EvalInCaller
+        include FilenameHelpers
+        STACK_OFFSET = 12
+        attr_reader :stack_offset
+
+        def self.create(stack_offset: STACK_OFFSET)
+          new(stack_offset: stack_offset).create
+        end
+
+        def initialize(stack_offset:)
+          @stack_offset = stack_offset
+        end
+
+        def create
+          # ensure evaluated and memoised with correct stack offset
+          class_method
+
+          CodeLocation.method_from(
+            object:       object,
+            method_name:  meth,
+            file:         file,
+            line_number:  line,
+            class_method: class_method,
+          )
+        end
+
+        private
+
+        def object
+          @object ||= eval_in_caller("self", stack_offset)
+        end
+
+        def class_method
+          return @class_method if defined?(@class_method)
+
+          @class_method = eval_in_caller("is_a?(Module)", STACK_OFFSET)
+        end
+
+        RUBY_IS_MAIN                = "self.class == Object && self&.to_s == 'main' && __method__.nil?"
+        RUBY_SOURCE_LOCATION        = "(__method__).source_location if __method__"
+        RUBY_CLASS_METHOD_SOURCE    = "method#{RUBY_SOURCE_LOCATION}"
+        RUBY_INSTANCE_METHOD_SOURCE = "self.class.instance_method#{RUBY_SOURCE_LOCATION}"
+
+        def method_finder
+          @method_finder ||= class_method ? RUBY_CLASS_METHOD_SOURCE : RUBY_INSTANCE_METHOD_SOURCE
+        end
+
+        def file
+          @file ||= eval_in_caller("(#{RUBY_IS_MAIN}) ? __FILE__ : ((#{method_finder})&.first)", stack_offset)
+        end
+
+        def line
+          @line ||= eval_in_caller("(#{RUBY_IS_MAIN}) ? __LINE__ : ((#{method_finder})&.last)", stack_offset)
+        end
+
+        def meth
+          @meth ||= eval_in_caller("__method__", stack_offset)
+        end
+      end
+    end
+  end
+end

data/lib/delfos/method_trace/code_location/eval_in_caller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "binding_of_caller"
+
+module Delfos
+  module MethodTrace
+    module CodeLocation
+      module EvalInCaller
+        def eval_in_caller(s, offset, &block)
+          other = binding.of_caller(offset)
+
+          other.eval(s)
+        end
+      end
+    end
+  end
+end

data/lib/delfos/method_trace/code_location/filename_helpers.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Delfos
+  module MethodTrace
+    module CodeLocation
+      module FilenameHelpers
+        def path
+          file
+        end
+
+        def file
+          relative_filename(@file)
+        end
+
+        def raw_path
+          @file
+        end
+
+        private
+
+        def relative_filename(f)
+          return unless f
+          file = f.to_s
+
+          Delfos.application_directories.map do |d|
+            file = relative_path(file, d)
+          end
+
+          file
+        end
+
+        def relative_path(file, dir)
+          dir = File.expand_path(dir)
+          match = dir.to_s.split("/")[0..-2].join("/")
+
+          if match.length.positive? && file[match]
+            file = file.gsub(match, "").
+                   gsub(%r{^/}, "")
+          end
+
+          file
+        end
+      end
+    end
+  end
+end

data/lib/delfos/method_trace/code_location/method.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "filename_helpers"
+
+module Delfos
+  module MethodTrace
+    module CodeLocation
+      class Method
+        include FilenameHelpers
+        attr_reader :object, :line_number, :class_method
+
+        def initialize(object:, method_name:, file:, line_number:, class_method:)
+          @object       = object
+          @method_name  = method_name
+          @file         = file
+          @line_number  = line_number
+          @class_method = class_method
+        end
+
+        def klass_name
+          klass.name
+        end
+
+        def klass
+          object.is_a?(Module) ? object : object.class
+        end
+
+        def method_name
+          (@method_name || "(main)").to_s
+        end
+
+        def method_type
+          class_method ? "ClassMethod" : "InstanceMethod"
+        end
+
+        def summary(reverse: false)
+          summary = [source_location, method_summary]
+
+          (reverse ? summary.reverse : summary).join " "
+        end
+
+        private
+
+        def method_summary
+          "#{klass}#{separator}#{method_name}"
+        end
+
+        def source_location
+          "#{file}:#{line_number}"
+        end
+
+        def separator
+          class_method ? "." : "#"
+        end
+      end
+    end
+  end
+end

data/lib/delfos/neo4j.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
-require_relative "neo4j/informer"
+
 require_relative "neo4j/query_execution/sync"
-require_relative "neo4j/batch/execution"
+require_relative "neo4j/batch/retryable"
 require_relative "neo4j/schema"
 require_relative "neo4j/distance/update"
 
@@ -14,11 +14,11 @@ module Delfos
     end
 
     def execute(query, params = {})
-      Batch::Execution.execute!(query, params: params)
+      Batch::Retryable.execute!(query, params: params, size: Delfos.batch_size)
     end
 
     def flush!
-      Batch::Execution.flush!
+      Batch::Retryable.flush!
     end
 
     def ensure_schema!

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

@@ -1,103 +1,42 @@
 # 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
+        attr_reader :size, :current_transaction_url, :commit_url, :expires, :query_count
 
         def initialize(size:, clock: Time)
-          @size                    = size
-          @clock                   = clock
-          @queries                 = []
-          @expires                 = nil
-          @commit_url              = nil
-          @current_transaction_url = nil
+          @size               = size
+          @clock              = clock
+          reset!
         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!
+        def execute!(query, params: {})
+          check_for_expiry!
 
-              perform_query(query, params)
-              flush_if_required!
-            end
-          end
+          perform_query(query, params)
+          flush_if_required!
         end
 
         def flush!
           return unless query_count.positive?
           return unless @commit_url
-          QueryExecution::Transactional.flush!(@commit_url)
+          QueryExecution::Transactional.commit!(@commit_url)
 
           reset!
         end
 
-        def query_count
-          queries.length
-        end
-
         private
 
         def perform_query(query, params)
           transactional_query = QueryExecution::Transactional.new(query, params, url)
+          @total_query_length += transactional_query.query_length
           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
+          @query_count += 1
         end
 
         def url
@@ -110,19 +49,21 @@ module Delfos
           Delfos.neo4j.uri_for("/db/data/transaction")
         end
 
-        def check_for_expiry!
-          return unless @expires
+        def flush_if_required!
+          check_for_expiry!
 
-          if @clock.now > @expires
-            self.class.batch = nil
-            raise QueryExecution::ExpiredTransaction.new(@comit_url, "")
+          if batch_full? || expires_soon? || large_query?
+            flush!
+            return true
           end
+
+          false
         end
 
-        def flush_if_required!
-          check_for_expiry!
+        def check_for_expiry!
+          return if @expires.nil? || (@clock.now <= @expires)
 
-          flush! if batch_full? || expires_soon?
+          raise QueryExecution::ExpiredTransaction.new(@commit_url, "")
         end
 
         def batch_full?
@@ -130,18 +71,19 @@ module Delfos
         end
 
         def expires_soon?
-          @expires && (@clock.now + 2 > @expires)
+          @expires && (@clock.now + 10 > @expires)
         end
 
-        def reset!
-          @queries = []
-          reset_transaction!
+        def large_query?
+          @total_query_length >= Delfos.max_query_size
         end
 
-        def reset_transaction!
+        def reset!
+          @query_count             = 0
+          @total_query_length      = 0
           @current_transaction_url = nil
-          @commit_url = nil
-          @expires = nil
+          @commit_url              = nil
+          @expires                 = nil
         end
       end
     end