find-non-lambda-logs

Detect Kotlin Android Log calls using string interpolation without lambda overloads.

Updated Mar 13, 2026

Search Tags:#performance #logging #code audit #android #kotlin #log optimization

Ready to run

npx skills add https://github.com/fsales/curso-android-capgemini-proway --skill find-non-lambda-logs

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: find-non-lambda-logs
Source: https://github.com/fsales/curso-android-capgemini-proway/tree/main/exercicio/EAluno/.github/skills/find-non-lambda-logs
Command: npx skills add https://github.com/fsales/curso-android-capgemini-proway --skill find-non-lambda-logs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill identifies inefficient Kotlin Android Log calls that create unnecessary string allocations when debug and info logs are filtered out, helping improve logging performance.

Core Features & Use Cases

Log Pattern Auditing: Finds Log.d, Log.i, Log.w, and Log.e calls that use string interpolation without lambda overloads or required throwable handling.
Logging Hygiene Checks: Detects direct android.util.Log usage that bypasses shared logging wrappers and release filtering strategies.
Use Case: Review an Android codebase after adding new logs or migrating logging infrastructure to locate allocation-heavy logging statements that should be optimized.

Quick Start

Use the find-non-lambda-logs skill to audit my Kotlin Android project for inefficient Log calls and suggest the required lambda conversions.

Frequently Asked Questions about find-non-lambda-logs

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I find inefficient Android logging patterns in Kotlin?▼

Inefficient Kotlin Android logging occurs when Log.d, Log.i, Log.w, and Log.e calls use direct string interpolation instead of lambda overloads, causing unnecessary string allocations even when debug logs are filtered out during runtime.

How do I audit my Android codebase for non-lambda Log statements?▼

You can audit Log.d, Log.i, Log.w, and Log.e calls by performing pattern-based Kotlin source inspection to identify string interpolation misuse, throwable exceptions, and direct android.util.Log leakage bypassing shared wrappers.

When do I need to check for string interpolation misuse in Android logs?▼

Check for string interpolation misuse in Log.d, Log.i, Log.w, and Log.e calls when reviewing an Android codebase after adding new logs or migrating logging infrastructure to locate and optimize allocation-heavy logging statements.

Does this logging audit detect direct android.util.Log usage?▼

Yes, the logging audit detects direct android.util.Log usage that bypasses shared logging wrappers and release filtering strategies by inspecting Kotlin source code patterns for leakage and interpolation misuse.

Can I use this audit for Kotlin Android code migrations?▼

Yes, you can use this logging audit for Kotlin Android code migrations to locate Log.d, Log.i, Log.w, and Log.e statements requiring lambda conversions and throwable exception handling during logging infrastructure updates.

What are the limitations of pattern-based source inspection for log optimization?▼

Pattern-based source inspection for log optimization is limited to detecting non-lambda Log statements with string interpolation in Kotlin Android code, requiring source access and focusing on static interpolation misuse rather than runtime performance profiling.