chore(release): v0.1.4

- add `@forward_logger` for module-local forwarding wrappers
- add `set_log_level!(::Bool)` convenience switch
- make `@clog` accept no-group form
- forward `id` in `clog` and update docs/tests

	modified:   .gitignore
	modified:   CHANGELOG.md
	modified:   Project.toml
	modified:   README.md
	modified:   docs/src/functions.md
	modified:   docs/src/macros.md
	modified:   src/ComponentLogging.jl
	modified:   src/docstrings.jl
	new file:   src/helpers.jl
	modified:   test/runtests.jl

Author: karei

.gitignore

@@ -1,3 +1,4 @@
+/playground
 /Manifest*.toml
 /docs/Manifest*.toml
 /docs/build/

CHANGELOG.md

@@ -4,33 +4,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
-
+## [0.1.4] - 2026-01-15
 ### Added
-- 
+- `@forward_logger` to generate module-local forwarding methods for a logger (or `Ref{<:AbstractLogger}`).
+- `set_log_level!(logger, group, on::Bool)` convenience switch.
 
 ### Changed
-- 
+- `@clog` now supports the no-group form `@clog level msg...`.
 
 ### Fixed
-- 
-
-### Deprecated
-- 
+- `clog` now forwards `id` to `Logging.handle_message`.
 
 ### Removed
-- 
-
-### Security
-- 
+- Removed overloads without an explicit `group` (`clog(logger, level, ...)`, `clogenabled(logger, level)`).
 
-## [0.1.0] - 2025-09-25
-### Added
-- Initial release of `ComponentLogging.jl`: component-level routing, `clog`/`clogf`, `bind_logger`, minimal PlainLogger style, warn+ file:line display, colorized levels.
+## [0.1.3] - 2026-01-14
+### Fixed
+- `@bind_logger`: fix sink keyword handling, remove `min=` handling, and use `mod=` keyword.
 
-## [0.1.1] - 2025-10-07
 ### Changed
-- Documentation: general improvements and clarifications.
+- Documentation: update `@bind_logger` docs and add a usage example.
+- Tests: add `@bind_logger` regression coverage.
+- CI: test against Julia `lts` and `1`.
+- Compat: relax Julia requirement to `julia = "1"`.
 
 ## [0.1.2] - 2025-10-13
 ### Changed
@@ -44,6 +40,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 - Ensure `handle_message` always returns `nothing` for type stability.
 
-[Unreleased]: https://github.com/<owner>/<repo>/compare/v0.1.1...HEAD
-[0.1.2]: https://github.com/<owner>/<repo>/compare/v0.1.1...v0.1.2
-[0.1.1]: https://github.com/<owner>/<repo>/compare/v0.1.0...v0.1.1
+## [0.1.1] - 2025-10-07
+### Changed
+- Documentation: general improvements and clarifications.
+
+## [0.1.0] - 2025-09-25
+### Added
+- Initial release of `ComponentLogging.jl`: component-level routing, `clog`/`clogf`, `bind_logger`, minimal PlainLogger style, warn+ file:line display, colorized levels.
+
+[Unreleased]: https://github.com/JuliaLogging/ComponentLogging.jl/compare/v0.1.4...HEAD
+[0.1.4]: https://github.com/JuliaLogging/ComponentLogging.jl/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/JuliaLogging/ComponentLogging.jl/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/JuliaLogging/ComponentLogging.jl/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/JuliaLogging/ComponentLogging.jl/compare/v0.1.0...v0.1.1

Project.toml

@@ -1,7 +1,7 @@
 name = "ComponentLogging"
 uuid = "3f6ec708-df3b-46b4-8b70-ec9fa53b9f7d"
 authors = ["karei <abcdvvvv@gmail.com>"]
-version = "0.1.3"
+version = "0.1.4"
 
 [deps]
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"

README.md

@@ -21,6 +21,7 @@ Julia’s `CoreLogging` module provides a solid foundation, and this package bui
 - High performance; negligible overhead when logging is disabled. See [Benchmarking](@ref).
 - Suited for controlling module‑wide output granularity using one (or a few) loggers.
 - Enables control‑flow changes based on hierarchical log levels to eliminate unnecessary computations from hot paths.
+- `@forward_logger` macro for ergonomic, module-local forwarding wrappers.
 
 ## Installation
 
@@ -49,7 +50,7 @@ Typically you pass a `ComponentLogger` configured with per-group rules and a sin
   * General rule:  `n → LogLevel(n)`.
   * Passing `LogLevel` values (e.g. `Info`) is also supported and equivalent.
 
-> **Why logger-first? Performance & type-stability.** No `global_logger()`: `clog`/`clogenabled`/`clogf` take an `AbstractLogger` as the first parameter, which also keeps behavior predictable under concurrency.
+> **Why logger-first? Performance & type-stability.** The stdlib logging macros (`@info`, `@logmsg`, …) typically start by looking up the current logger (task-local, with a global fallback). When you already have a logger (e.g. stored in a `const` or a `Ref`), calling `clog(logger, ...)` bypasses that lookup and can reduce overhead in hot paths, while keeping behavior explicit and predictable under concurrency.
 
 **`clog` — emit a log record for a group at a given level**
 
@@ -114,11 +115,17 @@ ComponentLogger
 
 **Forwarding helpers (recommended)** — ergonomic short paths used throughout your codebase
 
+```julia
+@forward_logger clogger
+```
+
+The macro above is equivalent to defining the following forwarding methods at module top-level (shown here for clarity):
+
 ```julia
 clog(args...; kwargs...) = ComponentLogging.clog(clogger, args...; kwargs...)
 clogenabled(args...)     = ComponentLogging.clogenabled(clogger, args...)
 clogf(f, args...)        = ComponentLogging.clogf(f, clogger, args...)
-set_log_level(g, lvl)    = ComponentLogging.set_log_level!(clogger, g, lvl)
+set_log_level!(g, lvl)   = ComponentLogging.set_log_level!(clogger, g, lvl)
 with_min_level(f, lvl)   = ComponentLogging.with_min_level(f, clogger, lvl)
 ```
 

docs/src/functions.md

@@ -8,6 +8,12 @@ This page documents the **function-first** logging APIs exported by `ComponentLo
 All functions require the logger to be passed explicitly as the first argument.
 In application code you will typically define *forwarding helpers* to avoid threading the logger manually.
 
+When you already have a logger available (e.g. stored in a `const` or a `Ref`), calling `clog(logger, ...)` bypasses the task-local logger lookup performed by stdlib logging macros (`@info`, `@logmsg`, …) and can reduce overhead in hot paths.
+
+## Forwarding macro
+
+`@forward_logger` generates module-local forwarding methods (`clog`, `clogenabled`, `clogf`, `set_log_level!`, `with_min_level`) so you can call them without explicitly passing a logger at every call site.
+
 !!! info
     The function APIs do not automatically pass the current module, file, or line information; you need to provide them manually if needed. In the example below, the current module, file, and line are explicitly passed at the call site.
 
@@ -19,4 +25,5 @@ In application code you will typically define *forwarding helpers* to avoid thre
 clog
 clogenabled
 clogf
-```
+@forward_logger
+```

docs/src/macros.md

@@ -17,7 +17,7 @@ function __init__()
 end
 # or
 function __init__()
-    @bind_logger logger
+    @bind_logger sink=logger
 end
 ```
 
@@ -35,4 +35,4 @@ get_logger
 @cerror
 @clogenabled
 @clogf
-```
+```

src/ComponentLogging.jl

@@ -6,7 +6,7 @@ export PlainLogger
 
 export ComponentLogger, get_logger, set_module_logger, set_log_level!, with_min_level
 export clog, clogenabled, clogf
-export @bind_logger, @clog, @cdebug, @cinfo, @cwarn, @cerror, @clogenabled, @clogf
+export @bind_logger, @clog, @cdebug, @cinfo, @cwarn, @cerror, @clogenabled, @clogf, @forward_logger
 
 const RuleKey = NTuple{N,Symbol} where {N}
 const DEFAULT_SYM = :__default__
@@ -53,6 +53,9 @@ function set_log_level!(logger::ComponentLogger, group, lvl::Union{Integer,LogLe
     return logger
 end
 
+set_log_level!(logger::ComponentLogger, group, on::Bool) =
+    set_log_level!(logger, group, on ? 0 : 1)
+
 "Temporarily set the minimum level within a do-block; restore afterward even if an exception is thrown; no lock"
 function with_min_level(f::Function, logger::ComponentLogger, lvl::Union{Integer,LogLevel})
     old_lvl = logger.min
@@ -125,52 +128,6 @@ function get_logger(mod::Module)
     end
 end
 
-## Generic macro: @clog level message [group]
-@inline function _enabled(logger::AbstractLogger, lvl::LogLevel, grp)
-    lvl >= Logging.min_enabled_level(logger) &&
-        Logging.shouldlog(logger, lvl, @__MODULE__, grp, nothing)
-end
-
-## clog
-function clog(logger::AbstractLogger, group::Union{Symbol,RuleKey}, level::Union{Integer,LogLevel}, message...; _module=nothing, file=nothing, line=nothing, kwargs...)::Nothing
-    grp = _tokey(group)
-    lvl = LogLevel(level)
-    if _enabled(logger, lvl, grp)
-        Logging.handle_message(logger, lvl, message, _module, grp, nothing, file, line; kwargs...)
-    end
-    nothing
-end
-
-clog(logger::AbstractLogger, level::Union{Integer,LogLevel}, message...;
-    _module=nothing, file=nothing, line=nothing, kwargs...) =
-    clog(logger, (DEFAULT_SYM,), level, message...; _module, file, line, kwargs...)
-
-## clogenabled
-function clogenabled(logger::AbstractLogger, group::Union{Symbol,RuleKey}, level::Union{Integer,LogLevel})::Bool
-    grp = _tokey(group)
-    lvl = LogLevel(level)
-    return _enabled(logger, lvl, grp)
-end
-
-clogenabled(logger::AbstractLogger, level::Union{Integer,LogLevel}) =
-    clogenabled(logger, (DEFAULT_SYM,), level)
-
-## clogf
-@inline function clogf(f::F, logger::AbstractLogger, group::Union{Symbol,RuleKey}, level::Union{Integer,LogLevel}; _module=nothing, file=nothing, line=nothing)::Nothing where {F<:Function}
-    grp = _tokey(group)
-    lvl = LogLevel(level)
-    if _enabled(logger, lvl, grp)
-        msg = f()
-        if msg !== nothing
-            Logging.handle_message(logger, lvl, msg_to_tuple(msg), _module, grp, nothing, file, line)
-        end
-    end
-    nothing
-end
-
-clogf(f::F, logger::AbstractLogger, level::Union{Integer,LogLevel}; _module=nothing, file=nothing, line=nothing) where {F<:Function} =
-    clogf(f, logger, (DEFAULT_SYM,), level; _module, file, line)
-
 ## Module binding macro
 macro bind_logger(args...)
     sink_ex  = nothing
@@ -201,124 +158,8 @@ macro bind_logger(args...)
     end
 end
 
-## macro
-macro clog(args...)
-    n = length(args)
-    n >= 2 || error("@clog: need (level, msgs...) or (group, level, msgs...)")
-
-    # accept only literal group: :sym or (:a,:b,...)
-    is_sym_lit(ex) = (ex isa QuoteNode && ex.value isa Symbol)
-    is_symtuple_lit(ex) = ex isa Expr && ex.head === :tuple &&
-                          all(a -> (a isa QuoteNode && a.value isa Symbol), ex.args)
-
-    grp_ast = :((ComponentLogging.DEFAULT_SYM,))  # default group
-
-    looks_like_group = (args[1] isa Symbol) || (args[1] isa Expr && args[1].head === :tuple) ||
-                       (args[1] isa QuoteNode)
-    if looks_like_group
-        if !(is_sym_lit(args[1]) || is_symtuple_lit(args[1]))
-            error("@clog: group must be a literal Symbol like :core or a tuple of literal Symbols like (:a,:b)")
-        end
-        grp_ast = is_sym_lit(args[1]) ? Expr(:tuple, args[1]) : args[1]
-        n >= 3 || error("@clog: with group, need (group, level, msgs...)")
-        lvl_ex = args[2]
-        msg_ps = args[3:end]
-    else
-        lvl_ex = args[1]
-        msg_ps = args[2:end]
-    end
-
-    msg_tuple = Expr(:tuple, map(esc, msg_ps)...)
-    mod, file, line = Base.CoreLogging.@_sourceinfo
-    return :(
-        let _lg = ComponentLogging.get_logger($mod),
-            _lvl = LogLevel($(esc(lvl_ex))),
-            _grp = $grp_ast
-
-            if _lvl >= Logging.min_enabled_level(_lg) && Logging.shouldlog(_lg, _lvl, $mod, _grp, nothing)
-                Logging.handle_message(_lg, _lvl, $msg_tuple, $mod, _grp, nothing, $file, $line)
-            end
-            nothing
-        end
-    )
-end
-
-macro clogf(args...)
-    n = length(args)
-    n >= 2 || error("@clogf: need (level, expr) or (group, level, expr)")
-
-    is_sym_lit(ex) = (ex isa QuoteNode && ex.value isa Symbol)
-    is_symtuple_lit(ex) = ex isa Expr && ex.head === :tuple &&
-                          all(a -> (a isa QuoteNode && a.value isa Symbol), ex.args)
-
-    grp_ast = :((ComponentLogging.DEFAULT_SYM,))  # default group
-
-    looks_like_group = (args[1] isa Symbol) || (args[1] isa Expr && args[1].head === :tuple) ||
-                       (args[1] isa QuoteNode)
-    if looks_like_group
-        if !(is_sym_lit(args[1]) || is_symtuple_lit(args[1]))
-            error("@clogf: group must be a literal Symbol like :core or a tuple of literal Symbols like (:a,:b)")
-        end
-        grp_ast = is_sym_lit(args[1]) ? Expr(:tuple, args[1]) : args[1]
-        n >= 3 || error("@clogf: with group, need (group, level, expr)")
-        lvl_ex = args[2]
-        body_ex = args[3]
-    else
-        lvl_ex = args[1]
-        body_ex = args[2]
-    end
-
-    mod, file, line = Base.CoreLogging.@_sourceinfo
-    return :(
-        let _lg = ComponentLogging.get_logger($mod),
-            _lvl = LogLevel($(esc(lvl_ex))),
-            _grp = $grp_ast
-
-            if _lvl >= Logging.min_enabled_level(_lg) && Logging.shouldlog(_lg, _lvl, $mod, _grp, nothing)
-                _msg = $(esc(body_ex))
-                if _msg isa Function
-                    _msg = _msg()
-                end
-                if _msg !== nothing
-                    Logging.handle_message(_lg, _lvl, ComponentLogging.msg_to_tuple(_msg),
-                        $mod, _grp, nothing, $file, $line)
-                end
-            end
-            nothing
-        end
-    )
-end
-
-macro clogenabled(group, lvl)
-    is_sym_lit(x) = (x isa QuoteNode && x.value isa Symbol)
-    is_tuple_sym_lit(x) = x isa Expr && x.head === :tuple &&
-                          all(y -> y isa QuoteNode && y.value isa Symbol, x.args)
-
-    grp_ast = is_sym_lit(group) ? Expr(:tuple, group) :
-              is_tuple_sym_lit(group) ? group :
-              error("@clogenabled: `group` must be a Symbol literal like :core ",
-        "or a tuple literal of Symbols like (:net,:http)")
-
-    return :(
-        let
-            _lg = ComponentLogging.get_logger(@__MODULE__)
-            _lvl = LogLevel($(esc(lvl)))
-            _grp = $grp_ast
-            _lvl >= Logging.min_enabled_level(_lg) &&
-                Logging.shouldlog(_lg, _lvl, @__MODULE__, _grp, nothing)
-        end
-    )
-end
-
-#! format: off
-macro cdebug(args...);  esc(:(ComponentLogging.@clog Debug $(args...)))  end
-macro cinfo(args...);   esc(:(ComponentLogging.@clog Info  $(args...)))  end
-macro cwarn(args...);   esc(:(ComponentLogging.@clog Warn  $(args...)))  end
-macro cerror(args...);  esc(:(ComponentLogging.@clog Error $(args...)))  end
-#! format: on
-
 ## Pretty show for ComponentLogger
-@inline _lvname(lv::LogLevel) = string(lv)
+_lvname(lv::LogLevel) = string(lv)
 
 @inline function _print_level(io::IO, lv::LogLevel)
     if get(io, :color, false)
@@ -437,6 +278,7 @@ function Base.show(io::IO, ::MIME"text/plain", logger::ComponentLogger)
     _print_tree(io, logger.rules)
 end
 
+include("helpers.jl")
 include("docstrings.jl")
 
 end # module