fn_registry/cpp/functions/core/logger.md

name, kind, lang, domain, version, purity, signature, description, tags, uses_functions, uses_types, returns, returns_optional, error_type, imports, tested, tests, test_file_path, file_path, framework, params, output, notes

name	kind	lang	domain	version	purity	signature	description	tags	uses_functions	uses_types	returns	returns_optional	error_type	imports	tested	tests	test_file_path	file_path	framework	params	output	notes
logger	function	cpp	core	1.0.0	impure	bool fn_log::logger_init(const char* file_path, fn_log::Level min_level = Level::Info); void fn_log::logger_close(); void fn_log::logger_set_level(Level); fn_log::Level fn_log::logger_level(); const char* fn_log::logger_path(); void fn_log::log_debug(const char* fmt, ...); void fn_log::log_info(const char* fmt, ...); void fn_log::log_warn(const char* fmt, ...); void fn_log::log_error(const char* fmt, ...); std::size_t fn_log::buffer_size(); const fn_log::Entry* fn_log::buffer_at(std::size_t); void fn_log::buffer_clear(); const char* fn_log::level_label(fn_log::Level)	Logger global thread-safe para apps C++ del registry. Escribe a archivo (cwd, junto al ejecutable) en modo append y mantiene un ring buffer in-memory de 2000 entradas que el visualizador log_window consume. Formato: [YYYY-MM-DD HH:MM:SS.mmm] [LEVEL] mensaje.	logger logging file infra thread-safe		log_level_cpp_core log_entry_cpp_core		false	error_go_core	chrono cstdarg cstdio ctime mutex string	false			cpp/functions/core/logger.cpp		name desc file_path Ruta del archivo de log relativa al cwd (junto al ejecutable). Modo append. Si vacio o nullptr, no se escribe a disco — solo buffer in-memory name desc min_level Nivel minimo a aceptar. Mensajes por debajo se descartan antes de tocar archivo o buffer name desc fmt Formato printf-style de log_debug/info/warn/error. Cada llamada produce una linea independiente name desc i Indice [0, buffer_size()) en el ring buffer. 0 = entrada mas antigua viva	logger_init retorna true si pudo abrir el archivo (false → solo buffer). logger_close cierra archivo (idempotente). log_* mutan estado global thread-safe. buffer_at retorna puntero valido o nullptr si i fuera de rango	consumido por cpp/framework/app_base.cpp (init/close automatico via AppConfig.log) y cpp/functions/core/log_window.cpp (lectura del buffer)

logger

Logger global, thread-safe, integrado en fn::run_app: las apps solo declaran un AppLogConfig y emiten con log_info(...) etc.

Uso desde una app

#include "app_base.h"
#include "core/logger.h"

int main() {
    return fn::run_app({
        .title = "Mi App",
        .log   = {.file_path = "mi_app.log",
                  .level     = static_cast<int>(fn_log::Level::Info)}
    }, render);
}

Tras esto, fn::run_app llama logger_init antes del primer frame y logger_close al exit. La app solo necesita usar los emisores:

fn_log::log_info ("usuario abrio archivo %s", path);
fn_log::log_warn ("retry %d/%d", attempt, max);
fn_log::log_error("connection failed: %s", reason);
fn_log::log_debug("estado interno: %d items", n);

Uso sin fn::run_app

Apps que arman su propio main loop deben llamar manualmente:

fn_log::logger_init("app.log", fn_log::Level::Info);
// ... vida de la app ...
fn_log::logger_close();

Reglas

• Ruta relativa al cwd (igual convencion que app_settings.ini).
• Modo append: relanzar la app conserva el historico previo en disco.
• Thread-safe: un mutex interno protege archivo + buffer + nivel.
• Truncacion: cada mensaje cabe en kEntryTextMax - 64 caracteres formateados; el resto se trunca silenciosamente.
• Si logger_init no se llama o falla, los log_* siguen siendo seguros: solo escriben al ring buffer in-memory (que la ventana Logs puede mostrar igualmente).

Integracion

• fn::AppConfig::log activa el logger desde el framework.
• fn_ui::log_window lee el ring buffer y pinta la ventana "Logs..." del menubar.