tng 0.5.4 → 0.5.5

data/lib/generators/tng/install_generator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rails/generators"
+require "tng/services/installer"
 
 module Tng
   module Generators
@@ -13,68 +14,24 @@ module Tng
         if File.exist?(initializer_path)
           say "Configuration file already exists at #{initializer_path}", :yellow
           if yes?("Do you want to overwrite it? (y/n)")
-            remove_file initializer_path
-            create_file initializer_path, configuration_template
+            Tng::Services::Installer.install(
+              project_root: Dir.pwd,
+              rails_project: true,
+              force: true
+            )
             say "TNG configuration file updated!", :green
           else
             say "Skipping configuration file creation.", :blue
           end
         else
-          create_file initializer_path, configuration_template
+          Tng::Services::Installer.install(
+            project_root: Dir.pwd,
+            rails_project: true,
+            force: false
+          )
           say "TNG configuration file created at #{initializer_path}", :green
         end
       end
-
-      private
-
-      def configuration_template
-        <<~RUBY
-          # frozen_string_literal: true
-
-          return unless Rails.env.development?
-
-          Tng.configure do |config|
-            # Get your API key from https://app.tng.sh/
-            config.api_key = ENV["TNG_API_KEY"]
-            config.base_url = ENV["API_BASE_URI"] || "https://app.tng.sh/"
-
-            # Test Helper File (optional - auto-detected if not set)
-            # Uncomment to override auto-detection with a custom path
-            # Default auto-detection checks: spec/rails_helper.rb, spec/spec_helper.rb, test/test_helper.rb
-            # config.test_helper_path = "spec/rails_helper.rb"
-
-            # Ignore paths (relative to project root)
-            # config.ignore_files = []
-            # config.ignore_folders = []
-
-            # Authentication Configuration
-            # Set to false if your application does not require authentication
-            # config.authentication_enabled = true
-
-            # ⚠️  IMPORTANT: AUTHENTICATION CONFIGURATION REQUIRED ⚠️
-            # You MUST configure your authentication methods below for TNG to work properly.
-            # Uncomment and modify the authentication_methods configuration:
-
-            # Authentication Methods (multiple methods supported)
-            # Supported authentication types: session, devise, jwt, token_auth, basic_auth, oauth, headers, custom, nil
-            # EXAMPLE: Uncomment and modify these examples to match your app's authentication:
-
-            # config.authentication_methods = [
-            #   {
-            #     method: "authenticate_user_via_session!",
-            #     file_location: "app/controllers/application_controller.rb",
-            #     auth_type: "session"
-            #   },
-            #   {
-            #     method: "authenticate_user_via_api_key!",
-            #     file_location: "app/controllers/application_controller.rb",
-            #     auth_type: "headers"
-            #   }
-            # ]
-            # ⚠️  Remember to configure your authentication methods above! ⚠️
-          end
-        RUBY
-      end
     end
   end
 end

data/lib/tng/api/http_client.rb

@@ -70,8 +70,6 @@ module Tng
       response
     end
 
-    # Verify if the API key is valid
-    # Returns: { valid: true/false, error: nil/String }
     def verify_auth
       response = get("cli/tng_rails/stats")
 

data/lib/tng/services/direct_generation.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require_relative "extract_methods"
 require_relative "file_type_detector"
 
@@ -18,8 +19,17 @@ module Tng
       end
 
       def display_audit_results(result)
-        audit_results = result[:audit_results]
-        return unless audit_results
+        # debug logs removed
+        audit_results = result[:audit_results] || result["audit_results"] || result[:result] || result["result"] || result
+        if audit_results.is_a?(String)
+          begin
+            audit_results = JSON.parse(audit_results)
+          rescue JSON::ParserError
+            audit_results = nil
+          end
+        end
+        # debug logs removed
+        return unless audit_results.is_a?(Hash)
 
         @go_ui.show_audit_results(audit_results, "issues")
       end
@@ -79,7 +89,15 @@ module Tng
       end
 
       def find_similar_files(base_name)
-        rails_root = defined?(Rails) && Rails.root ? Rails.root.to_s : Dir.pwd
+        unless Tng::Utils.rails_project?(Dir.pwd)
+          root = Dir.pwd
+          files = Tng::Services::FileDiscovery.list_ruby_files(root)
+          return files
+            .select { |f| File.basename(f, ".rb").include?(base_name) }
+            .map { |f| f.gsub(%r{^#{Regexp.escape(root)}/}, "") }
+        end
+
+        rails_root = defined?(::Rails) && ::Rails.root ? ::Rails.root.to_s : Dir.pwd
         similar_files = []
 
         %w[app/controllers app/models app/services app/service].each do |dir|
@@ -129,6 +147,7 @@ module Tng
         result = @go_ui.show_progress("Processing...") do |progress|
           generate_test_result(file_object, method_info, type, progress)
         end
+        # debug logs removed
 
         if result&.dig(:error)
           label =
@@ -185,6 +204,17 @@ module Tng
       def generate_test_result(file_object, method_info, type, progress)
         generator = Tng::Services::TestGenerator.new(@http_client)
 
+        if !Tng::Utils.rails_project?(Dir.pwd)
+          method_info = method_info.merge(test_type: method_info[:test_type] || "other")
+          return generator.run_for_ruby_method(file_object, method_info, progress: progress) unless @params[:trace] || @params[:audit] || @params[:xray]
+
+          if @params[:audit]
+            return generator.run_audit_for_ruby_method(file_object, method_info, progress: progress)
+          elsif @params[:xray]
+            return generator.run_xray_for_ruby_method(file_object, method_info, progress: progress)
+          end
+        end
+
         if @params[:trace]
           perform_trace_analysis(file_object, method_info, progress)
         elsif @params[:xray]

data/lib/tng/services/file_discovery.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "find"
+
+module Tng
+  module Services
+    class FileDiscovery
+      DEFAULT_EXCLUDE_DIRS = %w[
+        test spec features
+        tmp log vendor node_modules coverage dist build
+        .git db
+      ].freeze
+
+      def self.list_ruby_files(root = Dir.pwd)
+        files = []
+        root = File.expand_path(root)
+
+        Find.find(root) do |path|
+          if File.directory?(path)
+            name = File.basename(path)
+            if DEFAULT_EXCLUDE_DIRS.include?(name)
+              Find.prune
+            else
+              next
+            end
+          end
+
+          next unless path.end_with?(".rb")
+          next if Tng::Utils.ignored_path?(path)
+
+          files << path
+        end
+
+        files
+      end
+
+      def self.relative_paths(root = Dir.pwd)
+        root = File.expand_path(root)
+        list_ruby_files(root).map { |p| p.sub(%r{\A#{Regexp.escape(root)}/?}, "") }
+      end
+    end
+  end
+end

data/lib/tng/services/file_type_detector.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/string/inflections'
+begin
+  require "active_support/core_ext/string/inflections"
+rescue LoadError
+  # Optional in non-Rails environments
+end
+
+require_relative "file_discovery"
 
 module Tng
   module Services
@@ -53,6 +59,8 @@ module Tng
         }.freeze
 
         def detect_type(file_path)
+          return "other" unless Tng::Utils.rails_project?(Dir.pwd)
+
           normalized_path = normalize_path(file_path)
           TYPE_PATTERNS.find { |pattern, _| normalized_path.match?(pattern) }&.last || 'other'
         end
@@ -78,7 +86,16 @@ module Tng
             candidates << File.expand_path(file_with_ext)
           end
 
-          rails_root = defined?(Rails) && Rails.root ? Rails.root.to_s : Dir.pwd
+          unless Tng::Utils.rails_project?(Dir.pwd)
+            root = Dir.pwd
+            files = Tng::Services::FileDiscovery.list_ruby_files(root)
+            files.each do |file|
+              candidates << file if File.basename(file) == File.basename(file_with_ext)
+            end
+            return candidates.uniq
+          end
+
+          rails_root = defined?(::Rails) && ::Rails.root ? ::Rails.root.to_s : Dir.pwd
 
           SEARCH_PATHS.each do |dir|
             full_path = File.join(rails_root, dir, file_with_ext)

data/lib/tng/services/installer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Tng
+  module Services
+    class Installer
+      def self.configuration_template(rails: false)
+        header = if rails
+                   "return unless Rails.env.development?"
+                 else
+                   "if defined?(Rails) && Rails.respond_to?(:env)\n  return unless Rails.env.development?\nend"
+                 end
+
+        <<~RUBY
+          # frozen_string_literal: true
+
+          #{header}
+
+          Tng.configure do |config|
+            # Get your API key from https://app.tng.sh/
+            config.api_key = ENV["TNG_API_KEY"]
+            config.base_url = ENV["API_BASE_URI"] || "https://app.tng.sh/"
+
+            # Test Helper File (optional - auto-detected if not set)
+            # Uncomment to override auto-detection with a custom path
+            # Default auto-detection checks: spec/rails_helper.rb, spec/spec_helper.rb, test/test_helper.rb
+            # config.test_helper_path = "spec/rails_helper.rb"
+
+            # Ignore paths (relative to project root)
+            # config.ignore_files = []
+            # config.ignore_folders = []
+
+            # Authentication Configuration
+            # Set to false if your application does not require authentication
+            # config.authentication_enabled = true
+
+            # ⚠️  IMPORTANT: AUTHENTICATION CONFIGURATION REQUIRED ⚠️
+            # You MUST configure your authentication methods below for TNG to work properly.
+            # Uncomment and modify the authentication_methods configuration:
+
+            # Authentication Methods (multiple methods supported)
+            # Supported authentication types: session, devise, jwt, token_auth, basic_auth, oauth, headers, custom, nil
+            # EXAMPLE: Uncomment and modify these examples to match your app's authentication:
+
+            # config.authentication_methods = [
+            #   {
+            #     method: "authenticate_user_via_session!",
+            #     file_location: "app/controllers/application_controller.rb",
+            #     auth_type: "session"
+            #   },
+            #   {
+            #     method: "authenticate_user_via_api_key!",
+            #     file_location: "app/controllers/application_controller.rb",
+            #     auth_type: "headers"
+            #   }
+            # ]
+            # ⚠️  Remember to configure your authentication methods above! ⚠️
+          end
+        RUBY
+      end
+
+      def self.install(project_root:, rails_project:, force: false)
+        target = if rails_project
+                   File.join(project_root, "config", "initializers", "tng.rb")
+                 else
+                   File.join(project_root, "tng.rb")
+                 end
+
+        if File.exist?(target)
+          return [false, target] unless force
+        end
+
+        dir = File.dirname(target)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+        File.write(target, configuration_template(rails: rails_project))
+
+        [true, target]
+      end
+    end
+  end
+end

data/lib/tng/services/test_generator.rb

@@ -11,6 +11,7 @@ module Tng
     class TestGenerator
       GENERATE_TESTS_PATH = "cli/tng_rails/contents/generate_tests"
       CONTENT_RESPONSES_PATH = "cli/tng_rails/content_responses"
+      RUBY_CONTENT_RESPONSES_PATH = "cli/tng_ruby/content_responses"
       POLL_INTERVAL_SECONDS = 5 # Poll every 5 seconds
       MAX_POLL_DURATION_SECONDS = 420 # 7 minutes total
 
@@ -36,6 +37,10 @@ module Tng
         generate_test_for_type(other_file, method_info, :other, progress: progress)
       end
 
+      def run_for_ruby_method(other_file, method_info, progress: nil)
+        generate_test_for_ruby(other_file, method_info, progress: progress)
+      end
+
 
       # Audit mode - async, polls for completion
       def run_audit_for_controller_method(controller, method_info, progress: nil)
@@ -54,6 +59,10 @@ module Tng
         run_audit_for_type(other_file, method_info, :other, progress: progress)
       end
 
+      def run_audit_for_ruby_method(other_file, method_info, progress: nil)
+        run_audit_for_ruby(other_file, method_info, progress: progress)
+      end
+
       # X-Ray mode - async, polls for completion
       def run_xray_for_controller_method(controller, method_info, progress: nil)
         run_xray_for_type(controller, method_info, :controller, progress: progress)
@@ -71,6 +80,10 @@ module Tng
         run_xray_for_type(other_file, method_info, :other, progress: progress)
       end
 
+      def run_xray_for_ruby_method(other_file, method_info, progress: nil)
+        run_xray_for_ruby(other_file, method_info, progress: progress)
+      end
+
       def run_audit_for_type(file_object, method_info, type, progress: nil)
         response = send_audit_request_for_type(file_object, method_info, type)
         return { error: :network_error, message: "Network error" } unless response
@@ -90,7 +103,7 @@ module Tng
           return { error: :server_error, message: "No job_id returned" } unless job_id
 
           # Poll for completion (audit only)
-          result = poll_for_completion(job_id, progress: progress)
+          result = poll_for_completion(job_id, progress: progress, content_path: CONTENT_RESPONSES_PATH)
           return { error: :timeout, message: "Audit timed out" } unless result
 
           # Audit results come back as the result directly (not wrapped)
@@ -104,17 +117,18 @@ module Tng
       def send_audit_request_for_type(file_object, method_info, type)
         config = request_config
         name = file_object[:name] || File.basename(file_object[:path], ".rb")
+        enriched_method_info = enrich_method_info_with_trace_v2(file_object, method_info, ruby_mode: false)
 
         # Pass audit_mode: true as 8th parameter
         case type
         when :controller
-          Tng.send_request_for_controller(name, file_object[:path], method_info, *config, true, false)
+          Tng.send_request_for_controller(name, file_object[:path], enriched_method_info, *config, true, false)
         when :model
-          Tng.send_request_for_model(name, file_object[:path], method_info, *config, true, false)
+          Tng.send_request_for_model(name, file_object[:path], enriched_method_info, *config, true, false)
         when :service
-          Tng.send_request_for_service(name, file_object[:path], method_info, *config, true, false)
+          Tng.send_request_for_service(name, file_object[:path], enriched_method_info, *config, true, false)
         when :other
-          Tng.send_request_for_other(name, file_object[:path], method_info, *config, true, false)
+          Tng.send_request_for_other(name, file_object[:path], enriched_method_info, *config, true, false)
         end
       end
 
@@ -137,7 +151,7 @@ module Tng
           return { error: :server_error, message: "No job_id returned" } unless job_id
 
           # Poll for completion (similar to audit)
-          result = poll_for_completion(job_id, progress: progress)
+          result = poll_for_completion(job_id, progress: progress, content_path: CONTENT_RESPONSES_PATH)
           return { error: :timeout, message: "X-Ray generation timed out" } unless result
 
           # X-Ray results should contain mermaid_code and explanation
@@ -150,17 +164,18 @@ module Tng
       def send_xray_request_for_type(file_object, method_info, type)
         config = request_config
         name = file_object[:name] || File.basename(file_object[:path], ".rb")
+        enriched_method_info = enrich_method_info_with_trace_v2(file_object, method_info, ruby_mode: false)
 
         # Pass xray_mode: true as 9th parameter (audit_mode: false, xray_mode: true)
         case type
         when :controller
-          Tng.send_request_for_controller(name, file_object[:path], method_info, *config, false, true)
+          Tng.send_request_for_controller(name, file_object[:path], enriched_method_info, *config, false, true)
         when :model
-          Tng.send_request_for_model(name, file_object[:path], method_info, *config, false, true)
+          Tng.send_request_for_model(name, file_object[:path], enriched_method_info, *config, false, true)
         when :service
-          Tng.send_request_for_service(name, file_object[:path], method_info, *config, false, true)
+          Tng.send_request_for_service(name, file_object[:path], enriched_method_info, *config, false, true)
         when :other
-          Tng.send_request_for_other(name, file_object[:path], method_info, *config, false, true)
+          Tng.send_request_for_other(name, file_object[:path], enriched_method_info, *config, false, true)
         end
       end
 
@@ -186,7 +201,7 @@ module Tng
 
         return unless job_id
 
-        result = poll_for_completion(job_id, progress: progress)
+        result = poll_for_completion(job_id, progress: progress, content_path: CONTENT_RESPONSES_PATH)
 
         return unless result
 
@@ -196,7 +211,7 @@ module Tng
         file_result = Tng::Utils.save_test_file(result.to_json)
         return unless file_result
 
-        trigger_cleanup(job_id)
+        trigger_cleanup(job_id, content_path: CONTENT_RESPONSES_PATH)
 
         file_result.merge(generation_time: generation_time)
       end
@@ -204,20 +219,138 @@ module Tng
       def send_request_for_type(file_object, method_info, type)
         config = request_config
         name = file_object[:name] || File.basename(file_object[:path], ".rb")
+        enriched_method_info = enrich_method_info_with_trace_v2(file_object, method_info, ruby_mode: false)
 
         # Pass audit_mode: false as 8th parameter for normal test generation
         case type
         when :controller
-          Tng.send_request_for_controller(name, file_object[:path], method_info, *config, false, false)
+          Tng.send_request_for_controller(name, file_object[:path], enriched_method_info, *config, false, false)
         when :model
-          Tng.send_request_for_model(name, file_object[:path], method_info, *config, false, false)
+          Tng.send_request_for_model(name, file_object[:path], enriched_method_info, *config, false, false)
         when :service
-          Tng.send_request_for_service(name, file_object[:path], method_info, *config, false, false)
+          Tng.send_request_for_service(name, file_object[:path], enriched_method_info, *config, false, false)
         when :other
-          Tng.send_request_for_other(name, file_object[:path], method_info, *config, false, false)
+          Tng.send_request_for_other(name, file_object[:path], enriched_method_info, *config, false, false)
+        end
+      end
+
+      def generate_test_for_ruby(file_object, method_info, progress: nil)
+        start_time = Time.now
+
+        response = send_request_for_ruby(file_object, method_info, audit_mode: false, xray_mode: false)
+        return unless response
+
+        if response.is_a?(HTTPX::ErrorResponse)
+          return { error: :network_error, message: response.error&.message || "Network error" }
+        end
+
+        job_data = JSON.parse(response.body)
+        return { error: :auth_failed, message: "Invalid or missing API key" } if response.status == 401
+        return { error: :auth_failed, message: "API key expired or usage limit reached" } if response.status == 403
+
+        job_id = job_data["job_id"]
+        return unless job_id
+
+        result = poll_for_completion(job_id, progress: progress, content_path: RUBY_CONTENT_RESPONSES_PATH)
+        return unless result
+
+        end_time = Time.now
+        generation_time = end_time - start_time
+
+        file_result = Tng::Utils.save_test_file(result.to_json)
+        return unless file_result
+
+        trigger_cleanup(job_id, content_path: RUBY_CONTENT_RESPONSES_PATH)
+
+        file_result.merge(generation_time: generation_time)
+      end
+
+      def run_audit_for_ruby(file_object, method_info, progress: nil)
+        response = send_request_for_ruby(file_object, method_info, audit_mode: true, xray_mode: false)
+        return { error: :network_error, message: "Network error" } unless response
+
+        if response.is_a?(HTTPX::ErrorResponse)
+          return { error: :network_error, message: response.error&.message || "Network error" }
+        end
+
+        return { error: :auth_failed, message: "Invalid or missing API key" } if response.status == 401
+        return { error: :auth_failed, message: "API key expired" } if response.status == 403
+
+        begin
+          job_data = JSON.parse(response.body)
+          return { error: :server_error, message: job_data["error"] } if job_data["error"]
+
+          job_id = job_data["job_id"]
+          return { error: :server_error, message: "No job_id returned" } unless job_id
+
+          result = poll_for_completion(job_id, progress: progress, content_path: RUBY_CONTENT_RESPONSES_PATH)
+          return { error: :timeout, message: "Audit timed out" } unless result
+
+          { audit_results: result }
+        rescue JSON::ParserError => e
+          { error: :parse_error, message: "Failed to parse audit response: #{e.message}" }
+        end
+      end
+
+      def run_xray_for_ruby(file_object, method_info, progress: nil)
+        response = send_request_for_ruby(file_object, method_info, audit_mode: false, xray_mode: true)
+        return { error: :network_error, message: "Network error" } unless response
+
+        if response.is_a?(HTTPX::ErrorResponse)
+          return { error: :network_error, message: response.error&.message || "Network error" }
+        end
+
+        return { error: :auth_failed, message: "Invalid or missing API key" } if response.status == 401
+        return { error: :auth_failed, message: "API key expired" } if response.status == 403
+
+        begin
+          job_data = JSON.parse(response.body)
+          return { error: :server_error, message: job_data["error"] } if job_data["error"]
+
+          job_id = job_data["job_id"]
+          return { error: :server_error, message: "No job_id returned" } unless job_id
+
+          result = poll_for_completion(job_id, progress: progress, content_path: RUBY_CONTENT_RESPONSES_PATH)
+          return { error: :timeout, message: "X-Ray generation timed out" } unless result
+
+          result
+        rescue JSON::ParserError => e
+          { error: :parse_error, message: "Failed to parse X-Ray response: #{e.message}" }
         end
       end
 
+      def send_request_for_ruby(file_object, method_info, audit_mode:, xray_mode:)
+        config = request_config
+        name = file_object[:name] || File.basename(file_object[:path], ".rb")
+        enriched_method_info = enrich_method_info_with_trace_v2(file_object, method_info, ruby_mode: true)
+
+        Tng.send_request_for_ruby(name, file_object[:path], enriched_method_info, *config, audit_mode, xray_mode)
+      end
+
+      def enrich_method_info_with_trace_v2(file_object, method_info, ruby_mode:)
+        return method_info unless method_info.is_a?(Hash)
+        return method_info if method_info.key?(:trace_v2) || method_info.key?("trace_v2")
+
+        method_name = method_info[:name] || method_info["name"]
+        return method_info if method_name.to_s.empty?
+
+        class_name = method_info[:class_name] || method_info["class_name"]
+        project_root = Dir.pwd
+        path = File.expand_path(file_object[:path])
+
+        trace_v2 =
+          if ruby_mode
+            Tng::Analyzer::Context.analyze_symbolic_trace_ruby_v2(project_root, path, method_name, class_name)
+          else
+            Tng::Analyzer::Context.analyze_symbolic_trace_v2(project_root, path, method_name, class_name)
+          end
+
+        method_info.merge(trace_v2: trace_v2)
+      rescue StandardError => e
+        debug_log("Trace v2 enrichment failed for #{file_object[:path]}##{method_name}: #{e.message}") if debug_enabled?
+        method_info
+      end
+
       def request_config
         [
           Tng::Utils.fixture_content,
@@ -228,8 +361,8 @@ module Tng
       end
 
       # Modified method signature and added interrupt handler
-      def poll_for_completion(job_id, progress: nil)
-        start_time = Time.current
+      def poll_for_completion(job_id, progress: nil, content_path: CONTENT_RESPONSES_PATH)
+        start_time = Time.now
         attempts = 0
         max_attempts = MAX_POLL_DURATION_SECONDS / POLL_INTERVAL_SECONDS
 
@@ -238,7 +371,7 @@ module Tng
 
         loop do
           attempts += 1
-          seconds_elapsed = (Time.current - start_time).to_i
+          seconds_elapsed = (Time.now - start_time).to_i
 
           if seconds_elapsed > MAX_POLL_DURATION_SECONDS
             return { error: :timeout, message: "Test generation timed out after #{MAX_POLL_DURATION_SECONDS} seconds" }
@@ -256,7 +389,7 @@ module Tng
 
           sleep(POLL_INTERVAL_SECONDS)
 
-          status_response = @http_client.get("#{CONTENT_RESPONSES_PATH}/#{job_id}")
+          status_response = @http_client.get("#{content_path}/#{job_id}")
 
           if status_response.is_a?(HTTPX::ErrorResponse)
             debug_log("Status check failed: #{status_response.error&.message}") if debug_enabled?
@@ -370,8 +503,8 @@ module Tng
         end
       end
 
-      def trigger_cleanup(job_id)
-        @http_client.patch("#{CONTENT_RESPONSES_PATH}/#{job_id}/cleanup")
+      def trigger_cleanup(job_id, content_path: CONTENT_RESPONSES_PATH)
+        @http_client.patch("#{content_path}/#{job_id}/cleanup")
       rescue StandardError => e
         debug_log("Cleanup request failed: #{e.message}") if debug_enabled?
       end

data/lib/tng/services/testng.rb

@@ -1,6 +1,7 @@
 module Services
   class Testng
     STATS_PATH = "cli/tng_rails/stats"
+    RUBY_STATS_PATH = "cli/tng_ruby/stats"
 
     def initialize(http_client)
       @http_client = http_client
@@ -78,7 +79,8 @@ module Services
         "User-Agent" => "Tng/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
       }
 
-      response = @http_client.get(STATS_PATH, headers: headers)
+      path = Tng::Utils.rails_project?(Dir.pwd) ? STATS_PATH : RUBY_STATS_PATH
+      response = @http_client.get(path, headers: headers)
 
       return if response.is_a?(HTTPX::ErrorResponse)