langda 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b45008f13ae56ee2ae505fdf1fc551ad57bcbbf276187ee0c18514a7df713b23
-  data.tar.gz: ea8d92f235f9ade134def26368a35b1bf559f161162b36dd583b5470e59e3837
+  metadata.gz: 32128642b12f722a798887e1be70fd8820af2b498b4bb29848a27104a8002e9f
+  data.tar.gz: de5538f68d89d71fd05bd013afa126863755d11bdcd9d0ce302c5e61c1e01a92
 SHA512:
-  metadata.gz: a9b7e62d8337a902777f55b181a94032169f9fc82b16d1e594cc78d31f5403fb4233bf67fd4a9aa1a15ac98be3d22c506546dafc61f72ba840517fedf85ebf4e
-  data.tar.gz: 4af4462b9dc36fb19d83f88185eb9e7379fc6b364ce65b1eaf200894b1bf5b51e5da54810100a0fc51f3b218391d2fe66223692a3f4ebab6e798f02824a3bd12
+  metadata.gz: 36899fb283dc7ff1411c25b61c2e8e16abc52252ccd11a9281e5d329bc64ddee19e70239d21ea56a21b600cb97aea63397355a9ac8b0e9a517dce90347752b7f
+  data.tar.gz: e485b13e58ced52fe06e13255f8cfe0f069ee0446984f12333af914c752a6155bbdcc76039b112e1c9a7746160caa8acc5c6b5b8f7833f94c5d58e4ce51046f6

data/README.md

@@ -1,4 +1,4 @@
-# Langda
+# Langda • Preferred Development Environment
 
 **Langda** is a lightweight Ruby performance helper that automatically detects loops,
 counts their iterations, measures execution time, and logs slow loops — all without

data/lib/langda/patches.rb

@@ -1,105 +1,160 @@
-module Langda
-  module LoopPatch
-
-    #########################################################
-    # UNIVERSAL LOOP WRAPPER (SAFE)
-    #########################################################
-    def _safe_loop(kind, args, block)
-      # No block → run original method
-      return yield unless Langda.enabled? && block
-
-      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      count = 0
-
-      begin
-        inner = proc do |*yield_args|
-          count += 1
-          block.call(*yield_args)
+# frozen_string_literal: true
+
+require "logger"
+
+module IterationLogger
+  VERSION = "0.1.0"
+
+  ITERATION_METHODS = [
+    :each, :map, :collect, :select, :find_all, :reject, :grep, :grep_v,
+    :each_with_index, :flat_map, :inject, :reduce, :partition, :find,
+    :any?, :all?, :none?, :times
+  ].to_set.freeze
+
+  class << self
+    def logger
+      @logger ||= begin
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger
+        else
+          std_logger = ::Logger.new($stdout)
+          std_logger.level = ::Logger::INFO
+          std_logger.progname = "Langda Logger"
+          std_logger
         end
-
-        result = yield(inner)
-
-        _langda_log(kind, count, start)
-        result
-
-      rescue => e
-        Langda::Log.warn("Langda fallback for #{kind}: #{e.class} #{e.message}")
-        yield(block) # fallback super
       end
     end
 
+    # Enable the TracePoint listener (idempotent)
+    def enable!
+      return if enabled?
 
-    #########################################################
-    # ARRAY / ENUMERABLE LOOP METHODS
-    #########################################################
+      @tracepoint = TracePoint.new(:call, :c_call) do |tp|
+        begin
+          handle_tracepoint(tp)
+        rescue => e
+          # Avoid raising inside TracePoint (would be fatal)
+          logger.error("Langda Logger internal error: #{e.class}: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}")
+        end
+      end
 
-    def each(*args, &block)
-      _safe_loop(:each, args, block) { |inner| super(*args, &inner) }
+      @tracepoint.enable
+      @enabled = true
+      logger.info("Langda Logger enabled (version #{VERSION})")
     end
 
-    def map(*args, &block)
-      _safe_loop(:map, args, block) { |inner| super(*args, &inner) }
+    def disable!
+      return unless enabled?
+      @tracepoint&.disable
+      @tracepoint = nil
+      @enabled = false
+      logger.info("Langda Logger disabled")
     end
 
-    def select(*args, &block)
-      _safe_loop(:select, args, block) { |inner| super(*args, &inner) }
+    def enabled?
+      !!@enabled
     end
 
-    def reject(*args, &block)
-      _safe_loop(:reject, args, block) { |inner| super(*args, &inner) }
-    end
+    private
 
-    def each_with_index(*args, &block)
-      _safe_loop(:each_with_index, args, block) { |inner| super(*args, &inner) }
-    end
+    # Decide whether to log and what to log
+    def handle_tracepoint(tp)
+      method_sym = tp.method_id
+      return unless method_sym && ITERATION_METHODS.include?(method_sym)
 
-    def each_with_object(obj, &block)
-      _safe_loop(:each_with_object, [obj], block) { |inner| super(obj, &inner) }
-    end
+      path = tp.path
+      lineno = tp.lineno
 
+      # We only log when the call site is inside /app/
+      return unless path && path.include?("/app/")
 
-    #########################################################
-    # INTEGER LOOP METHODS
-    #########################################################
+      receiver = safe_receiver(tp)
+      class_name = receiver_class_name(receiver, tp)
 
-    def times(&block)
-      _safe_loop(:times, [], block) { |inner| super(&inner) }
-    end
+      method_name = method_sym.to_s
 
-    def upto(limit, &block)
-      _safe_loop(:upto, [limit], block) { |inner| super(limit, &inner) }
+      # Try to determine "current count" - number of elements to be iterated
+      count = determine_count(receiver, method_sym)
+
+      message = {
+        file: path,
+        line: lineno,
+        class: class_name,
+        method: method_name,
+        count: count
+      }
+
+      # Use Rails.logger if available, otherwise STDOUT via our logger
+      logger.info("Langda Logger: #{message}")
     end
 
-    def downto(limit, &block)
-      _safe_loop(:downto, [limit], block) { |inner| super(limit, &inner) }
+    # Safely fetch the receiver (tp.self can sometimes be nil/corrupt in odd cases; rescue)
+    def safe_receiver(tp)
+      tp.self
+    rescue => _
+      nil
     end
 
-    def step(limit = nil, step = nil, &block)
-      _safe_loop(:step, [limit, step], block) do |inner|
-        super(limit, step, &inner)
+    def receiver_class_name(receiver, tp)
+      if receiver
+        # Prefer actual receiver class name
+        receiver.class.name rescue tp.defined_class.to_s
+      else
+        # Fallback to defined_class or '?'
+        (tp.defined_class && tp.defined_class.to_s) || "Unknown"
       end
     end
 
+    # Best-effort to determine count:
+    # - For Integer#times, the receiver (an Integer) itself is the count
+    # - Prefer length, size, then count method if available, but call in safe rescue
+    # - For ActiveRecord::Relation, size may perform DB work; user should be aware
+    def determine_count(receiver, method_sym)
+      # Integer#times => receiver is an Integer
+      if method_sym == :times && receiver.is_a?(Integer)
+        return receiver
+      end
 
-    #########################################################
-    # LOGGER
-    #########################################################
-    def _langda_log(kind, count, start)
-      ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
-      return unless ms > Langda.threshold_ms
+      return nil unless receiver
+
+      # Try methods in an order that is best-effort and less likely to cause heavy DB ops
+      [:length, :size, :count].each do |m|
+        if receiver.respond_to?(m)
+          begin
+            val = receiver.public_send(m)
+            # Ensure it's numeric
+            return val if val.is_a?(Integer)
+          rescue => _
+            # swallow - sometimes ActiveRecord proxies may raise when calling count/size
+            next
+          end
+        end
+      end
 
-      Langda::Log.warn("#{kind} → #{count} iterations → #{ms.round(3)} ms")
+      nil
     end
-
   end
-end
-
 
-#########################################################
-# APPLY PATCHES
-#########################################################
+  # Railtie to auto-start in Rails apps
+  if defined?(Rails)
+    require "rails/railtie"
+
+    class Railtie < Rails::Railtie
+      initializer "iteration_logger.configure_rails_initialization" do
+        # Enable after Rails finishes initializing to ensure Rails.logger is available
+        ActiveSupport.on_load(:after_initialize) do
+          begin
+            IterationLogger.enable!
+          rescue => e
+            IterationLogger.logger.error("Langda Logger failed to enable: #{e.class}: #{e.message}")
+          end
+        end
+      end
 
-Array.prepend(Langda::LoopPatch)
-Hash.prepend(Langda::LoopPatch)
-Enumerable.prepend(Langda::LoopPatch)
-Integer.prepend(Langda::LoopPatch)
+      # Allow config flag to disable if apps wish to
+      rake_tasks do
+        # no rake tasks; placeholder so Rails doesn't warn about railtie with no hooks
+      end
+    end
+  end
+end

data/lib/langda/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Langda
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/langda.rb

@@ -1,4 +1,3 @@
-require "langda/logger"
 
 module Langda
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: langda
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - mrmalvi
@@ -42,7 +42,6 @@ files:
 - bin/console
 - bin/setup
 - lib/langda.rb
-- lib/langda/logger.rb
 - lib/langda/patches.rb
 - lib/langda/version.rb
 - sig/langda.rbs

data/lib/langda/logger.rb

@@ -1,20 +0,0 @@
-module Langda
-  module Log
-    APP_ROOT = Rails.root.to_s
-    def self.warn(msg)
-
-      loc = caller.find { |c| c.start_with?(APP_ROOT) }
-
-      loc = caller.find do |c|
-        c.include?("#{APP_ROOT}/app/")
-      end
-      return unless loc
-      file = loc.split(":")
-      if defined?(Rails) && Rails.logger
-        super("[Langda] #{msg} at #{file}")
-      else
-        puts ("[Langda] #{msg} at #{file}")
-      end
-    end
-  end
-end