LoggerAll

console.log universal. Cursor sobre una variable → ctrl+shift+l → inserta la línea de log del lenguaje del archivo.

total := a + b
fmt.Printf("🔹 main.go:5 Sum() total = %+v\n", total)

total = x + 1
print("🔹 main.py:3 run() total =", total)

let total = a + 1;
println!("🔹 lib.rs:3 sum() total = {:?}", total);

Y además:

• Toggle — el mismo atajo pone y quita el log.
• Panel lateral con todos los logs del proyecto, agrupados por archivo.
• Limpieza global — comentar o eliminar los logs de todo el espacio de trabajo, con confirmación y Ctrl+Z.
• Contexto real — Usuario.guardar(), el receptor en Go, y la variable de error de un catch.
• Numeración #1, #2… para seguir el orden de ejecución.
• Copiar sin insertar, para pegar en una consola o un ticket.

Lenguajes soportados

¿Falta el tuyo? → loggerAll.customTemplates (abajo). Sin plantilla, avisa que el lenguaje no está soportado.

Comandos

En macOS, Alt es la tecla Option (⌥) y Cmd es ⌘. Los comandos sin atajo se lanzan desde la paleta: Ctrl Shift P en Windows y Linux, Cmd Shift P en macOS — escribe «LoggerAll».

Multi-cursor soportado: un log por cursor. Comentar/eliminar solo toca líneas con el prefix.

También: clic derecho en el editor → menú LoggerAll, y bombilla 💡 sobre la variable/firma.

Cambiar o liberar los atajos

Ctrl/Cmd Shift L es por defecto Select All Occurrences en VS Code, en los tres sistemas. LoggerAll gana porque su cláusula when es más específica, pero si prefieres conservar el original, abre el editor de atajos y reasigna:

Busca loggerAll.insertLog, clic derecho → Change Keybinding. O edítalo a mano en keybindings.json (paleta → «Preferences: Open Keyboard Shortcuts (JSON)»):

[
  { "key": "ctrl+alt+d", "command": "loggerAll.insertLog", "when": "editorTextFocus" },
  { "key": "ctrl+shift+l", "command": "-loggerAll.insertLog" }
]

La segunda línea, con el - delante del comando, es la que devuelve Ctrl Shift L a VS Code.

Linux: algunos entornos de escritorio capturan combinaciones con Alt antes de que lleguen al editor (en GNOME, Alt+arrastrar mueve ventanas). Si un atajo con Alt no responde, libéralo en los ajustes del sistema o reasigna el comando a otra combinación con el método de arriba.

Toggle: el mismo atajo pone y quita

ctrl+shift+l sobre una variable que ya tiene su log justo debajo lo elimina en vez de duplicarlo. Solo se borra el log que menciona esa expresión, así que en una línea con varias variables cada una se alterna por separado. Desactivable con "loggerAll.toggle": false.

Todo el espacio de trabajo

Los comandos ...del espacio de trabajo recorren el proyecto entero, no solo el archivo activo:

• Se escanean las extensiones soportadas, saltando node_modules, dist, .git, etc. (ajustables en loggerAll.workspaceInclude / loggerAll.workspaceExclude).
• Eliminar pide confirmación con el número de logs y de archivos.
• Los cambios se aplican sin guardar, así que Ctrl+Z funciona archivo por archivo; al terminar se ofrece un botón Guardar todo.

Panel lateral

El icono LoggerAll en la barra de actividad lista todos los logs del proyecto agrupados por archivo, con un contador en la insignia. Clic en un log salta a su línea; la ✕ borra ese log; la 🗑 de un archivo borra los suyos. Se actualiza al guardar y con el botón ↻.

Ver todos los logs, no solo los tuyos

El botón del ojo 👁 en el título del panel alterna entre dos modos:

En el modo «todos», los logs ajenos se marcan como ajeno en la descripción y con un círculo más grande. Sirve para dejar un archivo o un proyecto completamente limpio antes de un commit, no solo libre de los logs que insertó la extensión.

La detección se amplía en ese modo: en Go entran también Println/Fprintln, en JS console.warn, error, trace y table, y en Rust print!. En Ruby, en cambio, se ignora el p suelto para no confundir p = 1 con un log.

Sobre el borrado. Los logs ajenos suelen ser logging real de la aplicación, así que:

• La ✕ de un log concreto y la 🗑 de un archivo sí los alcanzan, y la 🗑 pide confirmación diciéndote cuántos de los que va a borrar no son de LoggerAll.
• Los comandos de borrado masivo del proyecto y el atajo Ctrl/Cmd Shift Alt D nunca los tocan: siguen limitados a las líneas con prefix, para que un atajo rápido no pueda arrasar el logging de producción.

Se puede fijar el modo desde los ajustes con "loggerAll.showAllLogs": true.

Log de función completa

Cursor sobre la firma → un solo log con todos los parámetros:

func Sum(a, b int) int {
	fmt.Printf("🔹 main.go:2 Sum() a=%+v b=%+v\n", a, b)

function greet(name, age) {
  console.log("🔹 app.ts:2 greet()", { name, age });

Contexto: clase y errores

La etiqueta califica el método con su clase, y en Go usa el receptor:

class Usuario:
    def guardar(self, x):
        print("🔹 users.py:3 Usuario.guardar() x =", x)

func (s *Server) Handle(w int) {
	fmt.Printf("🔹 srv.go:2 Server.Handle() w = %+v\n", w)

Con el cursor sobre un catch — o sobre un if err != nil en Go — se loguea la variable del error sin tener que seleccionarla:

} catch (err) {
  console.log("🔹 api.ts:5 Api.load() err =", err);

Cubre catch (JS/TS, Java, C#, PHP, Kotlin, Dart, C++), except … as (Python), rescue => (Ruby), Err(e) (Rust), catch implícito de Swift (error) y if err != nil (Go). Ajustes: loggerAll.includeClassName, loggerAll.logErrorInCatch.

Numerar los logs

"loggerAll.autoIncrement": true añade un contador para seguir el orden de ejecución:

fmt.Printf("🔹 #1 main.go:5 Sum() total = %+v\n", total)
fmt.Printf("🔹 #2 main.go:9 Sum() resto = %+v\n", resto)

El contador es por archivo: al insertar toma el mayor #n del archivo + 1, así que nunca colisiona. LoggerAll: Renumerar logs los resecuencia desde 1 por orden de aparición y se lo agrega a los que todavía no lo tengan.

Copiar sin insertar

ctrl+shift+alt+l construye la misma línea de log y la deja en el portapapeles sin tocar el archivo — para pegarla en una consola de depuración, un REPL o un ticket. Respeta multi-cursor (una línea por cursor).

Renumerar

El archivo:línea se congela al insertar. Tras mover código: LoggerAll: Renumerar logs lo corrige. Automático al guardar → "loggerAll.renumberOnSave": true.

Ajustes (settings.json)

Etiqueta

Comportamiento

Espacio de trabajo

Por lenguaje

Plantilla propia — placeholders {{label}} y {{expr}}:

"loggerAll.customTemplates": {
  "haskell": "putStrLn (\"{{label}} \" ++ show {{expr}})",
  "sql": "-- {{label}} {{expr}}"
}

Apoyar el proyecto

LoggerAll es software libre bajo licencia MIT. Si te ahorra tiempo cada día, puedes apadrinar su desarrollo en GitHub Sponsors — también aparece como botón Sponsor en la página de la extensión dentro de VS Code.