b6886d222b
## Summary
Implement structured file-based logging with per-component separation
and crash stacktrace capture.
### Log output structure
```
.clice/logs/2026-04-05_10-30-00_<pid>/
master.log
SF-0.log
SF-1.log
SL-0.log
```
### Changes
**Logging infrastructure** (`logging.h`, `logging.cpp`)
- `file_logger()` creates a dual-sink logger (file + stderr), so logs go
to both the file and terminal
- Pre-checks log directory creation and file writability before
constructing spdlog sinks; falls back to existing stderr logger on
failure
- `install_crash_handler()` uses LLVM's `AddSignalHandler` +
`PrintStackTraceOnErrorSignal` to write crash stacktraces into the
component's log file (and also to stderr)
- Fix `LOG_MESSAGE` macro: wrap in `do { } while(0)` to prevent
dangling-else
- Fix typo: `file_loggger` → `file_logger`
**Config** (`config.h`, `config.cpp`)
- Add `logging_dir` field to `CliceConfig`, defaulting to
`<cache_dir>/logs/`
- Apply `${workspace}` variable substitution to `logging_dir`
**Master server** (`master_server.h`, `master_server.cpp`)
- After config loads, create a session directory named
`<timestamp>_<pid>` under `logging_dir` and switch master to file
logging
- Pass session log directory to worker pool
**Worker pool** (`worker_pool.h`, `worker_pool.cpp`)
- Pass `--worker-name` (e.g. `SF-0`, `SL-1`) and `--log-dir` to spawned
worker processes
- Add `log_dir` to `WorkerPoolOptions`
**Workers** (`stateful_worker.h/cpp`, `stateless_worker.h/cpp`)
- Accept `worker_name` and `log_dir` parameters; switch to file logging
when `log_dir` is provided
**CLI cleanup** (`clice.cc`)
- Remove `--stateful-worker-count`, `--stateless-worker-count` from CLI
(config-file only)
- Group internal worker args (`--worker-memory-limit`, `--worker-name`,
`--log-dir`) separately
**Docs** (`docs/clice.toml`)
- Fix `logging_dir` example: `.clice/logging` → `.clice/logs`
## Test plan
- [x] `pixi run cmake-build RelWithDebInfo` compiles successfully
- [ ] Verify log files created under `.clice/logs/<timestamp>_<pid>/`
- [ ] Verify each component writes to its own file
- [ ] Verify crash stacktrace appears in component log file
- [ ] Verify `logging_dir` override in `clice.toml` works
- [ ] Verify graceful fallback when log directory is not writable
🤖 Generated with [Claude Code](https://claude.com/claude-code)
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **New Features**
* Session-specific logging directories (timestamped) and per-worker log
files
* CLI options to set worker name and log directory; general log level
control
* Configurable logging directory with default `<cache_dir>/logs/`
* **Bug Fixes**
* Fixed file-logging name/initialization issues; ensures directory
creation and deterministic filenames
* Added crash-handler support to append stack traces to logs
* **Documentation**
* Updated example config to use `${workspace}/.clice/logs`
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
100 lines
3.2 KiB
C++
100 lines
3.2 KiB
C++
#include "server/config.h"
|
|
|
|
#include <algorithm>
|
|
#include <thread>
|
|
|
|
#include "eventide/serde/toml.h"
|
|
#include "support/filesystem.h"
|
|
#include "support/logging.h"
|
|
|
|
namespace clice {
|
|
|
|
/// Replace all occurrences of ${workspace} with the workspace root.
|
|
static void substitute_workspace(std::string& value, const std::string& workspace_root) {
|
|
constexpr std::string_view placeholder = "${workspace}";
|
|
std::string::size_type pos = 0;
|
|
while((pos = value.find(placeholder, pos)) != std::string::npos) {
|
|
value.replace(pos, placeholder.size(), workspace_root);
|
|
pos += workspace_root.size();
|
|
}
|
|
}
|
|
|
|
void CliceConfig::apply_defaults(const std::string& workspace_root) {
|
|
auto cpu_count = std::thread::hardware_concurrency();
|
|
if(cpu_count == 0)
|
|
cpu_count = 4;
|
|
|
|
if(stateful_worker_count == 0) {
|
|
stateful_worker_count = std::max(1u, cpu_count / 4);
|
|
}
|
|
if(stateless_worker_count == 0) {
|
|
stateless_worker_count = std::max(1u, cpu_count / 4);
|
|
}
|
|
if(worker_memory_limit == 0) {
|
|
worker_memory_limit = 4ULL * 1024 * 1024 * 1024; // 4GB default
|
|
}
|
|
if(cache_dir.empty() && !workspace_root.empty()) {
|
|
cache_dir = path::join(workspace_root, ".clice");
|
|
}
|
|
|
|
if(index_dir.empty() && !cache_dir.empty()) {
|
|
index_dir = path::join(cache_dir, "index");
|
|
}
|
|
|
|
if(logging_dir.empty() && !cache_dir.empty()) {
|
|
logging_dir = path::join(cache_dir, "logs");
|
|
}
|
|
|
|
// Apply variable substitution to string fields
|
|
substitute_workspace(compile_commands_path, workspace_root);
|
|
substitute_workspace(cache_dir, workspace_root);
|
|
substitute_workspace(index_dir, workspace_root);
|
|
substitute_workspace(logging_dir, workspace_root);
|
|
}
|
|
|
|
std::optional<CliceConfig> CliceConfig::load(const std::string& path,
|
|
const std::string& workspace_root) {
|
|
auto content = fs::read(path);
|
|
if(!content) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
auto result = eventide::serde::toml::parse<CliceConfig>(*content);
|
|
if(!result) {
|
|
LOG_WARN("Failed to parse config file {}", path);
|
|
return std::nullopt;
|
|
}
|
|
|
|
auto config = std::move(*result);
|
|
config.apply_defaults(workspace_root);
|
|
|
|
LOG_INFO("Loaded config from {}", path);
|
|
return config;
|
|
}
|
|
|
|
CliceConfig CliceConfig::load_from_workspace(const std::string& workspace_root) {
|
|
if(!workspace_root.empty()) {
|
|
// Try standard config file locations
|
|
for(auto* name: {"clice.toml", ".clice/config.toml"}) {
|
|
auto config_path = path::join(workspace_root, name);
|
|
if(llvm::sys::fs::exists(config_path)) {
|
|
auto config = load(config_path, workspace_root);
|
|
if(config)
|
|
return std::move(*config);
|
|
}
|
|
}
|
|
}
|
|
|
|
// No config file found; use defaults
|
|
CliceConfig config;
|
|
config.apply_defaults(workspace_root);
|
|
LOG_INFO(
|
|
"No clice.toml found, using default configuration " "(stateful={}, stateless={}, memory_limit={}MB)",
|
|
config.stateful_worker_count,
|
|
config.stateless_worker_count,
|
|
config.worker_memory_limit / (1024 * 1024));
|
|
return config;
|
|
}
|
|
|
|
} // namespace clice
|