peak_flow_utils 0.1.15 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4fb7a276f751a58ba19b74e73955323e0f1b89215312b50ee3e3b9cf89a85f4
-  data.tar.gz: 29edd9b2f4225cf2ea74c67d4fccd1b21a0149781f2cacc168309ef8dd3082c6
+  metadata.gz: c01a814a1aad134f668f7144f6addea59f8b8afdc75a2ae8ff2280dbe3a9867c
+  data.tar.gz: b6746741a1ff204c7b2a31319409d84a4529c14a55f8e9cfbf7b7fcad37eacea
 SHA512:
-  metadata.gz: 18328934879ae9fbb148e812926d68b5dca82837f929e5c3f3228bc4bc34bb140e8d42013333ef68976931819960d45110b26a8bf8bb2b37e363b8a519bf0ee9
-  data.tar.gz: 4251f1f1213fc0e9dfa426c7c4a1e75c53dbd23dff37ce09213f857ff7b7fba56251875d17a7baed74273d744f29b03bd9fa3e41f7a877319ada3cf9760bf9b4
+  metadata.gz: 5a82e952b87453cfde4fbcb42fd43a0f2bca93f43dc2b3dbdca3109c6d25a21dd587745c602680d89c446cda1c1be251167b46248b98bc1e5354f408ae9f2758
+  data.tar.gz: d2020073122505feaa6cb3923f79a76ff6f8608ac45af16625cae83f79c6232a9f4ac677e834faa015bfd1d9e287946b4cc0662557507dcfab89ea7c3faf665e

data/app/services/peak_flow_utils/deep_merger.rb

@@ -1,18 +1,35 @@
 class PeakFlowUtils::DeepMerger < PeakFlowUtils::ApplicationService
-  def initialize(hashes:)
+  attr_reader :hashes, :object_mappings
+
+  def initialize(hashes:, object_mappings: {})
     @hashes = hashes
+    @object_mappings = object_mappings
   end
 
   def perform
     merged = {}
 
-    @hashes.each do |hash|
+    hashes.each do |hash|
       merge_hash(hash, merged)
     end
 
     succeed! merged
   end
 
+  def clone_something(object)
+    if object.is_a?(Hash)
+      new_hash = {}
+      merge_hash(object, new_hash)
+      new_hash
+    elsif object.is_a?(Array)
+      new_array = []
+      merge_array(object, new_array)
+      new_array
+    else
+      object
+    end
+  end
+
   def merge_something(object, merged)
     if object.is_a?(Array)
       merge_array(object, merged)
@@ -25,20 +42,20 @@ class PeakFlowUtils::DeepMerger < PeakFlowUtils::ApplicationService
 
   def merge_array(array, merged)
     array.each do |value|
-      merged << value
+      merged << clone_something(value)
     end
   end
 
   def merge_hash(hash, merged)
     hash.each do |key, value|
-      if !merged.key?(key)
-        merged[key] = value
-      elsif value.is_a?(Array)
+      if value.is_a?(Array)
+        merged[key] = []
         merge_array(value, merged[key])
       elsif value.is_a?(Hash)
+        merged[key] ||= {}
         merge_hash(value, merged[key])
       else
-        raise "Unknown object: #{object.class.name}"
+        merged[key] = clone_something(value)
       end
     end
   end

data/lib/peak_flow_utils/inherited_local_var.rb

@@ -0,0 +1,84 @@
+require "monitor"
+require_relative "thread_callbacks_patch"
+
+Thread.on_initialize do |parent:, thread:|
+  thread.instance_variable_set(:@_inherited_local_vars, parent.instance_variable_get(:@_inherited_local_vars))
+end
+
+Thread.class_eval do
+  def self.inherited_local_vars_mutex
+    @inherited_local_vars_mutex ||= Mutex.new
+  end
+
+  def self._inherited_local_vars
+    Thread.current.instance_variable_set(:@_inherited_local_vars, {}) unless Thread.current.instance_variable_get(:@_inherited_local_vars)
+    Thread.current.instance_variable_get(:@_inherited_local_vars)
+  end
+
+  def self.inherited_local_vars_reset
+    ObjectSpace.each_object(Thread) do |thread|
+      inherited_local_vars_mutex.synchronize do
+        thread.instance_variable_set(:@_inherited_local_vars, nil)
+      end
+    end
+  end
+
+  def self.inherited_local_vars_delete(key)
+    inherited_local_vars_mutex.synchronize do
+      raise "Key didn't exist: #{key}" unless _inherited_local_vars.key?(key)
+
+      _inherited_local_vars.delete(key)
+    end
+  rescue ThreadError # This can happen when process is closing down
+    _inherited_local_vars.delete(key)
+  end
+
+  def self.inherited_local_vars_fetch(key)
+    inherited_local_vars_mutex.synchronize do
+      return _inherited_local_vars.fetch(key)
+    end
+  end
+
+  def self.inherited_local_vars_get(key)
+    inherited_local_vars_mutex.synchronize do
+      return _inherited_local_vars[key]
+    end
+  end
+
+  def self.inherited_local_vars_set(values)
+    inherited_local_vars_mutex.synchronize do
+      current_vars = _inherited_local_vars
+      new_vars = PeakFlowUtils::DeepMerger.execute!(hashes: [current_vars, values])
+      Thread.current.instance_variable_set(:@_inherited_local_vars, new_vars)
+    end
+  end
+end
+
+class PeakFlowUtils::InheritedLocalVar
+  attr_reader :identifier
+
+  def self.finalize(inherited_local_var_object_id)
+    Thread.inherited_local_vars_delete("inherited_local_var_#{inherited_local_var_object_id}")
+  rescue Exception => e # rubocop:disable Lint/RescueException
+    puts e.inspect # rubocop:disable Rails/Output
+    puts e.backtrace # rubocop:disable Rails/Output
+
+    raise e
+  end
+
+  def initialize(new_value = nil)
+    ObjectSpace.define_finalizer(self, PeakFlowUtils::InheritedLocalVar.method(:finalize))
+
+    @identifier = "inherited_local_var_#{__id__}"
+
+    Thread.inherited_local_vars_set(identifier => new_value)
+  end
+
+  def value
+    Thread.inherited_local_vars_fetch(identifier)
+  end
+
+  def value=(new_value)
+    Thread.inherited_local_vars_set(identifier => new_value)
+  end
+end

data/lib/peak_flow_utils/notifier.rb

@@ -2,73 +2,89 @@ class PeakFlowUtils::Notifier
   class FailedToReportError < RuntimeError; end
   class NotConfiguredError < RuntimeError; end
 
-  attr_reader :auth_token
+  attr_reader :auth_token, :mutex, :parameters
 
   def self.configure(auth_token:)
     @current = PeakFlowUtils::Notifier.new(auth_token: auth_token)
   end
 
-  def self.current
-    raise PeakFlowUtils::Notifier::NotConfiguredError, "Hasn't been configured" if !@current && Rails.env.test?
-
+  def self.current # rubocop:disable Style/TrivialAccessors
     @current
   end
 
-  def self.current_parameters(parameters: nil)
-    hashes = PeakFlowUtils::Notifier.current_parameters_hashes
-    hashes << parameters if parameters
-
-    PeakFlowUtils::DeepMerger.execute!(hashes: hashes)
+  def self.notify(*args, **opts, &blk)
+    PeakFlowUtils::Notifier.current&.notify(*args, **opts, &blk)
   end
 
-  def self.current_parameters_hashes
-    hashes = []
+  def self.reset_parameters
+    ::PeakFlowUtils::Notifier.current&.instance_variable_set(:@parameters, ::PeakFlowUtils::InheritedLocalVar.new({}))
+  end
 
-    Thread.current[:peakflow_utils] ||= {}
-    Thread.current[:peakflow_utils].dig(:notifier, :with_parameters)&.each_value do |more_parameters|
-      hashes << more_parameters
-    end
+  def self.with_parameters(parameters)
+    return yield unless ::PeakFlowUtils::Notifier.current
 
-    hashes
-  end
+    random_id = ::SecureRandom.hex(16)
 
-  def self.notify(*args, **opts, &blk)
-    PeakFlowUtils::Notifier.current.notify(*args, **opts, &blk)
-  end
+    ::PeakFlowUtils::Notifier.current.mutex.synchronize do
+      raise "'parameters' was nil?" if ::PeakFlowUtils::Notifier.current.parameters.value.nil?
 
-  def self.with_parameters(parameters)
-    random_id = SecureRandom.hex(16)
+      parameters_with = ::PeakFlowUtils::Notifier.current.parameters.value.clone
+      parameters_with[random_id] = parameters
 
-    Thread.current[:peakflow_utils] ||= {}
-    Thread.current[:peakflow_utils][:notifier] ||= {}
-    Thread.current[:peakflow_utils][:notifier][:with_parameters] ||= {}
-    Thread.current[:peakflow_utils][:notifier][:with_parameters][random_id] = parameters
+      ::PeakFlowUtils::Notifier.current.parameters.value = parameters_with
+    end
 
     begin
       yield
     ensure
-      Thread.current[:peakflow_utils][:notifier][:with_parameters].delete(random_id)
+      ::PeakFlowUtils::Notifier.current.mutex.synchronize do
+        parameters_without = ::PeakFlowUtils::Notifier.current.parameters.value.clone
+        parameters_without.delete(random_id)
+
+        ::PeakFlowUtils::Notifier.current.parameters.value = parameters_without
+      end
     end
   end
 
   def initialize(auth_token:)
     @auth_token = auth_token
+    @mutex = ::Mutex.new
+    @parameters = ::PeakFlowUtils::InheritedLocalVar.new({})
+  end
+
+  def current_parameters(parameters: nil)
+    hashes = current_parameters_hashes
+    hashes << parameters if parameters
+
+    ::PeakFlowUtils::DeepMerger.execute!(hashes: hashes)
+  end
+
+  def current_parameters_hashes
+    parameters.value.values
+  end
+
+  def error_message_from_response(response)
+    message = "Couldn't report error to Peakflow (code #{response.code})"
+
+    if response["content-type"]&.starts_with?("application/json")
+      response_data = ::JSON.parse(response.body)
+      message << ": #{response_data.fetch("errors").join(". ")}" if response_data["errors"]
+    end
+
+    message
   end
 
   def notify(error:, environment: nil, parameters: nil)
-    error_parser = PeakFlowUtils::NotifierErrorParser.new(
+    error_parser = ::PeakFlowUtils::NotifierErrorParser.new(
       backtrace: error.backtrace,
       environment: environment,
       error: error
     )
 
-    merged_parameters = PeakFlowUtils::Notifier.current_parameters(parameters: parameters)
+    merged_parameters = current_parameters(parameters: parameters)
 
     uri = URI("https://www.peakflow.io/errors/reports")
 
-    https = Net::HTTP.new(uri.host, uri.port)
-    https.use_ssl = true
-
     data = {
       auth_token: auth_token,
       error: {
@@ -85,18 +101,25 @@ class PeakFlowUtils::Notifier
       }
     }
 
-    request = Net::HTTP::Post.new(uri.path)
+    send_notify_request(data: data, uri: uri)
+  end
+
+  def send_notify_request(data:, uri:)
+    https = ::Net::HTTP.new(uri.host, uri.port)
+    https.use_ssl = true
+
+    request = ::Net::HTTP::Post.new(uri.path)
     request["Content-Type"] = "application/json"
-    request.body = JSON.generate(data)
+    request.body = ::JSON.generate(data)
 
     response = https.request(request)
 
     raise FailedToReportError, error_message_from_response(response) unless response.code == "200"
 
-    response_data = JSON.parse(response.body)
+    response_data = ::JSON.parse(response.body)
 
     # Data not always present so dont use fetch
-    PeakFlowUtils::NotifierResponse.new(
+    ::PeakFlowUtils::NotifierResponse.new(
       bug_report_id: response_data["bug_report_id"],
       bug_report_instance_id: response_data["bug_report_instance_id"],
       project_id: response_data["project_id"],
@@ -104,15 +127,4 @@ class PeakFlowUtils::Notifier
       url: response_data["url"]
     )
   end
-
-  def error_message_from_response(response)
-    message = "Couldn't report error to Peakflow (code #{response.code})"
-
-    if response["content-type"]&.starts_with?("application/json")
-      response_data = JSON.parse(response.body)
-      message << ": #{response_data.fetch("errors").join(". ")}" if response_data["errors"]
-    end
-
-    message
-  end
 end

data/lib/peak_flow_utils/thread_callbacks_patch.rb

@@ -0,0 +1,23 @@
+class Thread
+  alias_method :_initialize, :initialize # rubocop:disable Style/Alias
+
+  def self.on_initialize(&callback)
+    @@on_initialize_count = 0 if @on_initialize_count.nil? # rubocop:disable Style/ClassVars
+    count_to_use = @@on_initialize_count
+    @@on_initialize_count += 1 # rubocop:disable Style/ClassVars
+
+    @@on_initialize_callbacks ||= {} # rubocop:disable Style/ClassVars
+    @@on_initialize_callbacks[count_to_use] = callback
+
+    count_to_use
+  end
+
+  def initialize(*args, &block)
+    @@on_initialize_callbacks ||= {} # rubocop:disable Style/ClassVars
+    @@on_initialize_callbacks.each_value do |callback|
+      callback.call(parent: Thread.current, thread: self)
+    end
+
+    _initialize(*args, &block)
+  end
+end

data/lib/peak_flow_utils/version.rb

@@ -1,3 +1,3 @@
 module PeakFlowUtils
-  VERSION = "0.1.15".freeze
+  VERSION = "0.1.16".freeze
 end

data/lib/peak_flow_utils.rb

@@ -6,7 +6,11 @@ require "service_pattern"
 module PeakFlowUtils
   path = "#{__dir__}/peak_flow_utils"
   models_path = "#{__dir__}/peak_flow_utils/models"
+  services_path = File.realpath("#{__dir__}/../app/services/peak_flow_utils")
 
+  autoload :ApplicationService, "#{services_path}/application_service"
+  autoload :DeepMerger, "#{services_path}/deep_merger"
+  autoload :InheritedLocalVar, "#{path}/inherited_local_var"
   autoload :Notifier, "#{path}/notifier"
   autoload :NotifierErrorParser, "#{path}/notifier_error_parser"
   autoload :NotifierRack, "#{path}/notifier_rack"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: peak_flow_utils
 version: !ruby/object:Gem::Version
-  version: 0.1.15
+  version: 0.1.16
 platform: ruby
 authors:
 - kaspernj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-10 00:00:00.000000000 Z
+date: 2022-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -66,6 +66,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -147,6 +175,7 @@ files:
 - lib/peak_flow_utils.rb
 - lib/peak_flow_utils/engine.rb
 - lib/peak_flow_utils/handler_helper.rb
+- lib/peak_flow_utils/inherited_local_var.rb
 - lib/peak_flow_utils/migrations/20150902155200_create_translation_keys.rb
 - lib/peak_flow_utils/migrations/20150907070908_create_handlers.rb
 - lib/peak_flow_utils/migrations/20150907070909_create_groups.rb
@@ -166,6 +195,7 @@ files:
 - lib/peak_flow_utils/notifier_rails.rb
 - lib/peak_flow_utils/notifier_response.rb
 - lib/peak_flow_utils/notifier_sidekiq.rb
+- lib/peak_flow_utils/thread_callbacks_patch.rb
 - lib/peak_flow_utils/version.rb
 - lib/tasks/peak_flow_utils_tasks.rake
 homepage: https://github.com/kaspernj/peak_flow_utils