lib/ddmemoize.rb in ddmemoize-1.0.0a2 vs lib/ddmemoize.rb in ddmemoize-1.0.0a3

@@ -13,43 +13,35 @@
     def initialize(value)
       @value = value
     end
   end
 
-  # @api private
-  class TelemetryMap
-    include Singleton
+  NONE = Object.new
 
-    def initialize
-      @map = {}
+  def self.activate(mod)
+    mod.extend(Mixin)
+  end
+
+  class << self
+    def enable_telemetry
+      @telemetry_enabled = true
     end
 
-    def [](mod)
-      @map[mod]
+    def telemetry_enabled?
+      @telemetry_enabled
     end
 
-    def []=(mod, telemetry)
-      @map[mod] = telemetry
+    def telemetry_counter
+      @_telemetry_counter ||= DDTelemetry::Counter.new
     end
   end
 
-  NONE = Object.new
-
-  def self.activate(mod, telemetry: nil)
-    mod.extend(Mixin)
-    TelemetryMap.instance[mod] = telemetry
-  end
-
-  def self.telemetry_for(mod)
-    TelemetryMap.instance[mod]
-  end
-
-  def self.print_telemetry(telemetry)
+  def self.print_telemetry
     headers = %w[memoization hit miss %]
 
-    rows_raw = telemetry.counter(:memoization).map do |(name, type), counter|
-      { name: name, type: type, count: counter.value }
+    rows_raw = DDMemoize.telemetry_counter.map do |(name, type), count|
+      { name: name, type: type, count: count }
     end
 
     rows = rows_raw.group_by { |r| r[:name] }.map do |name, rows_for_name|
       rows_by_type = rows_for_name.group_by { |r| r[:type] }
 
@@ -68,27 +60,25 @@
     def memoize(method_name)
       original_method_name = '__nonmemoized_' + method_name.to_s
       alias_method original_method_name, method_name
 
       instance_cache = Hash.new { |hash, key| hash[key] = {} }
-      telemetry = DDMemoize.telemetry_for(self)
+      counter_label = "#{self}##{method_name}"
 
       define_method(method_name) do |*args|
         instance_method_cache = instance_cache[self]
 
         value = NONE
         if instance_method_cache.key?(args)
           object = instance_method_cache[args].object
           value = object ? object.value : NONE
         end
 
-        if telemetry
-          counter_label = is_a?(Class) ? "#{self}.#{method_name}" : "#{self.class}##{method_name}"
-
+        if DDMemoize.telemetry_enabled?
           if NONE.equal?(value)
-            telemetry.counter(:memoization).increment([counter_label, :miss])
+            DDMemoize.telemetry_counter.increment([counter_label, :miss])
           else
-            telemetry.counter(:memoization).increment([counter_label, :hit])
+            DDMemoize.telemetry_counter.increment([counter_label, :hit])
           end
         end
 
         if value.equal?(NONE)
           send(original_method_name, *args).tap do |r|