lazy string formatting

Author: KRRT7

codeflash/languages/javascript/import_resolver.py

@@ -61,7 +61,7 @@ def resolve_import(self, import_info: ImportInfo, source_file: Path) -> Resolved
 
         # Skip external packages (node_modules)
         if self._is_external_package(module_path):
-            logger.debug(f"Skipping external package: {module_path}")
+            logger.debug("Skipping external package: %s", module_path)
             return None
 
         # Check cache
@@ -79,7 +79,7 @@ def resolve_import(self, import_info: ImportInfo, source_file: Path) -> Resolved
         self._resolution_cache[cache_key] = resolved_path
 
         if resolved_path is None:
-            logger.debug(f"Could not resolve import: {module_path} from {source_file}")
+            logger.debug("Could not resolve import: %s from %s", module_path, source_file)
             return None
 
         return self._build_resolved_import(import_info, resolved_path)
@@ -145,7 +145,7 @@ def _resolve_relative_import(self, module_path: str, source_dir: Path) -> Path |
         try:
             base_path.relative_to(self.project_root)
         except ValueError:
-            logger.debug(f"Import path outside project root: {base_path}")
+            logger.debug("Import path outside project root: %s", base_path)
             return None
 
         # If the path already has an extension, try it directly first
@@ -439,7 +439,7 @@ def _extract_helper_from_file(
         try:
             source = file_path.read_text(encoding="utf-8")
         except Exception as e:
-            logger.warning(f"Failed to read {file_path}: {e}")
+            logger.warning("Failed to read %s: %s", file_path, e)
             return None
 
         # Get analyzer for this file type
@@ -488,7 +488,7 @@ def _extract_helper_from_file(
                     end_line=func.end_line,
                 )
 
-        logger.debug(f"Function {function_name} not found in {file_path}")
+        logger.debug("Function %s not found in %s", function_name, file_path)
         return None
 
     def _find_helpers_recursive(
@@ -518,7 +518,7 @@ def _find_helpers_recursive(
         try:
             source = file_path.read_text(encoding="utf-8")
         except Exception as e:
-            logger.warning(f"Failed to read {file_path}: {e}")
+            logger.warning("Failed to read %s: %s", file_path, e)
             return {}
 
         # Get analyzer and imports for this file

codeflash/languages/javascript/line_profiler.py

@@ -194,7 +194,7 @@ def _instrument_function(self, func: FunctionInfo, lines: list[str], file_path:
             tree = analyzer.parse(source.encode("utf8"))
             executable_lines = self._find_executable_lines(tree.root_node, source.encode("utf8"))
         except Exception as e:
-            logger.warning(f"Failed to parse function {func.name}: {e}")
+            logger.warning("Failed to parse function %s: %s", func.name, e)
             return func_lines
 
         # Add profiling to each executable line
@@ -329,5 +329,5 @@ def parse_results(profile_file: Path) -> dict:
             }
 
         except Exception as e:
-            logger.exception(f"Failed to parse line profile results: {e}")
+            logger.exception("Failed to parse line profile results: %s", e)
             return {"timings": {}, "unit": 1e-9, "functions": {}}

codeflash/languages/javascript/module_system.py

@@ -73,7 +73,7 @@ def detect_module_system(project_root: Path, file_path: Path | None = None) -> s
                     return ModuleSystem.COMMONJS
 
         except Exception as e:
-            logger.warning(f"Failed to parse package.json: {e}")
+            logger.warning("Failed to parse package.json: %s", e)
 
     # Strategy 2: Check file extension
     if file_path:
@@ -108,7 +108,7 @@ def detect_module_system(project_root: Path, file_path: Path | None = None) -> s
                     return ModuleSystem.COMMONJS
 
             except Exception as e:
-                logger.warning(f"Failed to analyze file {file_path}: {e}")
+                logger.warning("Failed to analyze file %s: %s", file_path, e)
 
     # Default to CommonJS (more common and backward compatible)
     logger.debug("Defaulting to CommonJS")

codeflash/languages/javascript/support.py

@@ -84,7 +84,7 @@ def discover_functions(
         try:
             source = file_path.read_text(encoding="utf-8")
         except Exception as e:
-            logger.warning(f"Failed to read {file_path}: {e}")
+            logger.warning("Failed to read %s: %s", file_path, e)
             return []
 
         try:
@@ -129,7 +129,7 @@ def discover_functions(
             return functions
 
         except Exception as e:
-            logger.warning(f"Failed to parse {file_path}: {e}")
+            logger.warning("Failed to parse %s: %s", file_path, e)
             return []
 
     def discover_functions_from_source(self, source: str, file_path: Path | None = None) -> list[FunctionInfo]:
@@ -184,7 +184,7 @@ def discover_functions_from_source(self, source: str, file_path: Path | None = N
             return functions
 
         except Exception as e:
-            logger.warning(f"Failed to parse source: {e}")
+            logger.warning("Failed to parse source: %s", e)
             return []
 
     def _get_test_patterns(self) -> list[str]:
@@ -248,7 +248,7 @@ def discover_tests(self, test_root: Path, source_functions: Sequence[FunctionInf
                                 TestInfo(test_name=test_name, test_file=test_file, test_class=None)
                             )
             except Exception as e:
-                logger.debug(f"Failed to analyze test file {test_file}: {e}")
+                logger.debug("Failed to analyze test file %s: %s", test_file, e)
 
         return result
 
@@ -299,7 +299,7 @@ def extract_code_context(self, function: FunctionInfo, project_root: Path, modul
         try:
             source = function.file_path.read_text()
         except Exception as e:
-            logger.exception(f"Failed to read {function.file_path}: {e}")
+            logger.exception("Failed to read %s: %s", function.file_path, e)
             return CodeContext(target_code="", target_file=function.file_path, language=Language.JAVASCRIPT)
 
         # Find imports and helper functions
@@ -623,7 +623,7 @@ def _find_helper_functions(
                     helpers.extend(file_helpers)
 
         except Exception as e:
-            logger.debug(f"Failed to find cross-file helpers: {e}")
+            logger.debug("Failed to find cross-file helpers: %s", e)
 
         return helpers
 
@@ -866,7 +866,7 @@ def _find_imported_type_definitions(
                         break
 
             except Exception as e:
-                logger.debug(f"Failed to resolve type definition for {local_name}: {e}")
+                logger.debug("Failed to resolve type definition for %s: %s", local_name, e)
                 continue
 
         return found_definitions
@@ -888,7 +888,7 @@ def find_helper_functions(self, function: FunctionInfo, project_root: Path) -> l
             imports = analyzer.find_imports(source)
             return self._find_helper_functions(function, source, analyzer, imports, project_root)
         except Exception as e:
-            logger.warning(f"Failed to find helpers for {function.name}: {e}")
+            logger.warning("Failed to find helpers for %s: %s", function.name, e)
             return []
 
     # === Code Transformation ===
@@ -913,7 +913,7 @@ def replace_function(self, source: str, function: FunctionInfo, new_source: str)
 
         """
         if function.start_line is None or function.end_line is None:
-            logger.error(f"Function {function.name} has no line information")
+            logger.error("Function %s has no line information", function.name)
             return source
 
         # Get analyzer for parsing
@@ -925,7 +925,7 @@ def replace_function(self, source: str, function: FunctionInfo, new_source: str)
         # Extract just the method body from the new source
         new_body = self._extract_function_body(new_source, function.name, analyzer)
         if new_body is None:
-            logger.warning(f"Could not extract body for {function.name} from optimized code, using full replacement")
+            logger.warning("Could not extract body for %s from optimized code, using full replacement", function.name)
             return self._replace_function_text_based(source, function, new_source, analyzer)
 
         # Find the original function and replace its body
@@ -1062,7 +1062,7 @@ def find_function_at_line(node, target_name: str, target_line: int):
 
         func_node = find_function_at_line(tree.root_node, function.name, function.start_line)
         if not func_node:
-            logger.warning(f"Could not find function {function.name} at line {function.start_line}")
+            logger.warning("Could not find function %s at line %s", function.name, function.start_line)
             return source
 
         # Find the body node in the original
@@ -1074,7 +1074,7 @@ def find_function_at_line(node, target_name: str, target_line: int):
                     break
 
         if not body_node:
-            logger.warning(f"Could not find body for function {function.name}")
+            logger.warning("Could not find body for function %s", function.name)
             return source
 
         # Get the indentation of the original body's opening brace
@@ -1250,7 +1250,7 @@ def format_code(self, source: str, file_path: Path | None = None) -> str:
         except (subprocess.TimeoutExpired, FileNotFoundError):
             pass
         except Exception as e:
-            logger.debug(f"Prettier formatting failed: {e}")
+            logger.debug("Prettier formatting failed: %s", e)
 
         return source
 
@@ -1300,10 +1300,10 @@ def run_tests(
             return results, junit_xml
 
         except subprocess.TimeoutExpired:
-            logger.warning(f"Test execution timed out after {timeout}s")
+            logger.warning("Test execution timed out after %ss", timeout)
             return [], junit_xml
         except Exception as e:
-            logger.exception(f"Test execution failed: {e}")
+            logger.exception("Test execution failed: %s", e)
             return [], junit_xml
 
     def parse_test_results(self, junit_xml_path: Path, stdout: str) -> list[TestResult]:
@@ -1363,7 +1363,7 @@ def parse_test_results(self, junit_xml_path: Path, stdout: str) -> list[TestResu
                     )
                 )
         except Exception as e:
-            logger.warning(f"Failed to parse JUnit XML: {e}")
+            logger.warning("Failed to parse JUnit XML: %s", e)
 
         return results
 
@@ -1731,10 +1731,10 @@ def instrument_source_for_line_profiler(
 
             # Write instrumented code to source file
             source_file_path.write_text(instrumented_source, encoding="utf-8")
-            logger.debug(f"Wrote instrumented source to {source_file_path}")  # noqa: G004
+            logger.debug("Wrote instrumented source to %s", source_file_path)
             return True  # noqa: TRY300
         except Exception as e:
-            logger.warning(f"Failed to instrument source for line profiling: {e}")  # noqa: G004
+            logger.warning("Failed to instrument source for line profiling: %s", e)
             return False
 
     def parse_line_profile_results(self, line_profiler_output_file: Path) -> dict:
@@ -1746,7 +1746,7 @@ def parse_line_profile_results(self, line_profiler_output_file: Path) -> dict:
                 # Format output string for display
                 str_out = self._format_js_line_profile_output(parsed_results)
                 return {"timings": parsed_results.get("timings", {}), "unit": 1e-9, "str_out": str_out}
-        logger.warning(f"No line profiler output file found at {line_profiler_output_file}")  # noqa: G004
+        logger.warning("No line profiler output file found at %s", line_profiler_output_file)
         return {"timings": {}, "unit": 0, "str_out": ""}
 
     def _format_js_line_profile_output(self, parsed_results: dict) -> str:
@@ -1984,6 +1984,6 @@ def format_code(self, source: str, file_path: Path | None = None) -> str:
         except (subprocess.TimeoutExpired, FileNotFoundError):
             pass
         except Exception as e:
-            logger.debug(f"Prettier formatting failed: {e}")
+            logger.debug("Prettier formatting failed: %s", e)
 
         return source

codeflash/languages/javascript/tracer.py

@@ -326,7 +326,7 @@ def _wrap_method(self, func_lines: list[str], func_name: str, file_path: Path, i
         # For methods, we wrap by reassigning them after definition
         # This is complex, so for now we'll return unwrapped
         # TODO: Implement method wrapping
-        logger.warning(f"Method wrapping not fully implemented for {func_name}")
+        logger.warning("Method wrapping not fully implemented for %s", func_name)
         return func_lines
 
     def _wrap_regular_function(
@@ -366,7 +366,7 @@ def parse_results(trace_file: Path) -> list[dict[str, Any]]:
                 with json_file.open("r") as f:
                     return json.load(f)
             except Exception as e:
-                logger.exception(f"Failed to parse trace JSON: {e}")
+                logger.exception("Failed to parse trace JSON: %s", e)
                 return []
 
         # Try SQLite database
@@ -398,5 +398,5 @@ def parse_results(trace_file: Path) -> list[dict[str, Any]]:
             return traces
 
         except Exception as e:
-            logger.exception(f"Failed to parse trace database: {e}")
+            logger.exception("Failed to parse trace database: %s", e)
             return []

codeflash/languages/python/support.py

@@ -128,7 +128,7 @@ def discover_functions(
             return functions
 
         except Exception as e:
-            logger.warning(f"Failed to discover functions in {file_path}: {e}")
+            logger.warning("Failed to discover functions in %s: %s", file_path, e)
             return []
 
     def discover_tests(self, test_root: Path, source_functions: Sequence[FunctionInfo]) -> dict[str, list[TestInfo]]:
@@ -183,7 +183,7 @@ def extract_code_context(self, function: FunctionInfo, project_root: Path, modul
         try:
             source = function.file_path.read_text()
         except Exception as e:
-            logger.exception(f"Failed to read {function.file_path}: {e}")
+            logger.exception("Failed to read %s: %s", function.file_path, e)
             return CodeContext(target_code="", target_file=function.file_path, language=Language.PYTHON)
 
         # Extract the function source
@@ -285,7 +285,7 @@ def find_helper_functions(self, function: FunctionInfo, project_root: Path) -> l
                         )
 
         except Exception as e:
-            logger.warning(f"Failed to find helpers for {function.name}: {e}")
+            logger.warning("Failed to find helpers for %s: %s", function.name, e)
 
         return helpers
 
@@ -319,7 +319,7 @@ def replace_function(self, source: str, function: FunctionInfo, new_source: str)
                 preexisting_objects=set(),
             )
         except Exception as e:
-            logger.warning(f"Failed to replace function {function.name}: {e}")
+            logger.warning("Failed to replace function %s: %s", function.name, e)
             return source
 
     def format_code(self, source: str, file_path: Path | None = None) -> str:
@@ -345,7 +345,7 @@ def format_code(self, source: str, file_path: Path | None = None) -> str:
         except (subprocess.TimeoutExpired, FileNotFoundError):
             pass
         except Exception as e:
-            logger.debug(f"Ruff formatting failed: {e}")
+            logger.debug("Ruff formatting failed: %s", e)
 
         # Try black as fallback
         try:
@@ -357,7 +357,7 @@ def format_code(self, source: str, file_path: Path | None = None) -> str:
         except (subprocess.TimeoutExpired, FileNotFoundError):
             pass
         except Exception as e:
-            logger.debug(f"Black formatting failed: {e}")
+            logger.debug("Black formatting failed: %s", e)
 
         return source
 
@@ -395,10 +395,10 @@ def run_tests(
             return results, junit_xml
 
         except subprocess.TimeoutExpired:
-            logger.warning(f"Test execution timed out after {timeout}s")
+            logger.warning("Test execution timed out after %ss", timeout)
             return [], junit_xml
         except Exception as e:
-            logger.exception(f"Test execution failed: {e}")
+            logger.exception("Test execution failed: %s", e)
             return [], junit_xml
 
     def parse_test_results(self, junit_xml_path: Path, stdout: str) -> list[TestResult]:
@@ -459,7 +459,7 @@ def parse_test_results(self, junit_xml_path: Path, stdout: str) -> list[TestResu
                     )
                 )
         except Exception as e:
-            logger.warning(f"Failed to parse JUnit XML: {e}")
+            logger.warning("Failed to parse JUnit XML: %s", e)
 
         return results
 

codeflash/languages/registry.py

@@ -89,19 +89,19 @@ def file_extensions(self) -> tuple[str, ...]:
         if ext_lower in _EXTENSION_REGISTRY:
             existing = _EXTENSION_REGISTRY[ext_lower]
             logger.warning(
-                f"Extension '{ext}' already registered to {existing.__name__}, overwriting with {cls.__name__}"
+                "Extension '%s' already registered to %s, overwriting with %s", ext, existing.__name__, cls.__name__
             )
         _EXTENSION_REGISTRY[ext_lower] = cls
 
     # Register by language
     if language in _LANGUAGE_REGISTRY:
         existing = _LANGUAGE_REGISTRY[language]
         logger.warning(
-            f"Language '{language}' already registered to {existing.__name__}, overwriting with {cls.__name__}"
+            "Language '%s' already registered to %s, overwriting with %s", language, existing.__name__, cls.__name__
         )
     _LANGUAGE_REGISTRY[language] = cls
 
-    logger.debug(f"Registered {cls.__name__} for language '{language}' with extensions {extensions}")
+    logger.debug("Registered %s for language '%s' with extensions %s", cls.__name__, language, extensions)
 
     return cls
 
@@ -241,7 +241,7 @@ def detect_project_language(project_root: Path, module_root: Path) -> Language:
     for ext, count in sorted(extension_counts.items(), key=lambda x: -x[1]):
         if ext in _EXTENSION_REGISTRY:
             cls = _EXTENSION_REGISTRY[ext]
-            logger.info(f"Detected language: {cls().language} (found {count} '{ext}' files)")
+            logger.info("Detected language: %s (found %d '%s' files)", cls().language, count, ext)
             return cls().language
 
     msg = f"No supported language detected in {module_root}"