506 lines
14 KiB
Plaintext
506 lines
14 KiB
Plaintext
// cell log - Manage log sink configuration
|
|
//
|
|
// Usage:
|
|
// cell log list Show sinks and channel routing
|
|
// cell log channels List channels with status
|
|
// cell log enable <channel> Enable a channel on terminal
|
|
// cell log disable <channel> Disable a channel on terminal
|
|
// cell log add <name> console [opts] Add a console sink
|
|
// cell log add <name> file <path> [opts] Add a file sink
|
|
// cell log remove <name> Remove a sink
|
|
// cell log route <channel> <sink> Route a channel to a sink
|
|
// cell log unroute <channel> <sink> Remove a channel from a sink
|
|
// cell log stack <channel> Enable stack traces on a channel
|
|
// cell log unstack <channel> Disable stack traces on a channel
|
|
|
|
var toml = use('toml')
|
|
var fd = use('fd')
|
|
var json = use('json')
|
|
|
|
var log_path = shop_path + '/log.toml'
|
|
|
|
function load_config() {
|
|
if (fd.is_file(log_path))
|
|
return toml.decode(text(fd.slurp(log_path)))
|
|
return null
|
|
}
|
|
|
|
function ensure_dir(path) {
|
|
if (fd.is_dir(path)) return
|
|
var parts = array(path, '/')
|
|
var current = starts_with(path, '/') ? '/' : ''
|
|
var i = 0
|
|
for (i = 0; i < length(parts); i++) {
|
|
if (parts[i] == '') continue
|
|
current = current + parts[i] + '/'
|
|
if (!fd.is_dir(current)) fd.mkdir(current)
|
|
}
|
|
}
|
|
|
|
function save_config(config) {
|
|
ensure_dir(shop_path)
|
|
fd.slurpwrite(log_path, stone(blob(toml.encode(config))))
|
|
}
|
|
|
|
function print_help() {
|
|
log.console("Usage: cell log <command> [options]")
|
|
log.console("")
|
|
log.console("Commands:")
|
|
log.console(" list Show sinks and channel routing")
|
|
log.console(" channels List channels with status")
|
|
log.console(" enable <channel> Enable a channel on terminal")
|
|
log.console(" disable <channel> Disable a channel on terminal")
|
|
log.console(" add <name> console [opts] Add a console sink")
|
|
log.console(" add <name> file <path> [opts] Add a file sink")
|
|
log.console(" remove <name> Remove a sink")
|
|
log.console(" route <channel> <sink> Route a channel to a sink")
|
|
log.console(" unroute <channel> <sink> Remove a channel from a sink")
|
|
log.console(" stack <channel> Enable stack traces on a channel")
|
|
log.console(" unstack <channel> Disable stack traces on a channel")
|
|
log.console("")
|
|
log.console("Options for add:")
|
|
log.console(" --format=pretty|bare|json Output format (default: pretty for console, json for file)")
|
|
log.console(" --channels=ch1,ch2 Channels to subscribe (default: *)")
|
|
log.console(" --exclude=ch1,ch2 Channels to exclude")
|
|
log.console(" --mode=append|overwrite File write mode (default: append)")
|
|
log.console(" --max_size=N Max file size in bytes before truncation")
|
|
}
|
|
|
|
function parse_opt(arg, prefix) {
|
|
var full = '--' + prefix + '='
|
|
if (starts_with(arg, full))
|
|
return text(arg, length(full), length(arg))
|
|
return null
|
|
}
|
|
|
|
// Collect all stack channels across all sinks
|
|
function collect_stack_channels(config) {
|
|
var stack_chs = {}
|
|
var names = array(config.sink)
|
|
arrfor(names, function(n) {
|
|
var s = config.sink[n]
|
|
if (is_array(s.stack)) {
|
|
arrfor(s.stack, function(ch) { stack_chs[ch] = true })
|
|
}
|
|
})
|
|
return stack_chs
|
|
}
|
|
|
|
// Find which sinks a stack channel is declared on (for modification)
|
|
function find_stack_sink(config, channel) {
|
|
var names = array(config.sink)
|
|
var found = null
|
|
arrfor(names, function(n) {
|
|
if (found) return
|
|
var s = config.sink[n]
|
|
if (is_array(s.stack)) {
|
|
arrfor(s.stack, function(ch) {
|
|
if (ch == channel) found = n
|
|
})
|
|
}
|
|
})
|
|
return found
|
|
}
|
|
|
|
function do_list() {
|
|
var config = load_config()
|
|
var names = null
|
|
var channel_routing = {}
|
|
var stack_chs = null
|
|
names = (config && config.sink) ? array(config.sink) : []
|
|
if (length(names) == 0) {
|
|
log.console("No log sinks configured.")
|
|
return
|
|
}
|
|
|
|
// Show sinks
|
|
log.console("Sinks:")
|
|
arrfor(names, function(n) {
|
|
var s = config.sink[n]
|
|
var fmt = s.format || (s.type == 'file' ? 'json' : 'pretty')
|
|
var mode = s.mode ? " mode=" + s.mode : ""
|
|
var maxsz = s.max_size ? " max_size=" + text(s.max_size) : ""
|
|
var ex = is_array(s.exclude) ? " exclude=" + text(s.exclude, ',') : ""
|
|
if (s.type == 'file')
|
|
log.console(" " + n + ": file -> " + s.path + " format=" + fmt + mode + maxsz)
|
|
else
|
|
log.console(" " + n + ": console format=" + fmt + ex)
|
|
})
|
|
|
|
// Build channel -> sinks map
|
|
arrfor(names, function(n) {
|
|
var s = config.sink[n]
|
|
var chs = is_array(s.channels) ? s.channels : []
|
|
arrfor(chs, function(ch) {
|
|
if (!channel_routing[ch]) channel_routing[ch] = []
|
|
channel_routing[ch][] = n
|
|
})
|
|
})
|
|
|
|
// Show routing
|
|
log.console("")
|
|
log.console("Routing:")
|
|
var channels = array(channel_routing)
|
|
arrfor(channels, function(ch) {
|
|
log.console(" " + ch + " -> " + text(channel_routing[ch], ', '))
|
|
})
|
|
|
|
// Show stack traces
|
|
stack_chs = collect_stack_channels(config)
|
|
var stack_list = array(stack_chs)
|
|
if (length(stack_list) > 0) {
|
|
log.console("")
|
|
log.console("Stack traces on: " + text(stack_list, ', '))
|
|
}
|
|
}
|
|
|
|
function do_add() {
|
|
var name = null
|
|
var sink_type = null
|
|
var path = null
|
|
var format = null
|
|
var channels = ["*"]
|
|
var exclude = null
|
|
var mode = null
|
|
var max_size = null
|
|
var config = null
|
|
var val = null
|
|
var i = 0
|
|
if (length(args) < 3) {
|
|
log.console("Usage: cell log add <name> console|file [path] [options]")
|
|
return
|
|
}
|
|
name = args[1]
|
|
sink_type = args[2]
|
|
|
|
if (sink_type == 'file') {
|
|
if (length(args) < 4) {
|
|
log.console("Usage: cell log add <name> file <path> [options]")
|
|
return
|
|
}
|
|
path = args[3]
|
|
format = "json"
|
|
i = 4
|
|
} else if (sink_type == 'console') {
|
|
format = "pretty"
|
|
i = 3
|
|
} else {
|
|
log.console("Unknown sink type: " + sink_type + " (use 'console' or 'file')")
|
|
return
|
|
}
|
|
|
|
for (i = i; i < length(args); i++) {
|
|
val = parse_opt(args[i], 'format')
|
|
if (val) { format = val; continue }
|
|
val = parse_opt(args[i], 'channels')
|
|
if (val) { channels = array(val, ','); continue }
|
|
val = parse_opt(args[i], 'exclude')
|
|
if (val) { exclude = array(val, ','); continue }
|
|
val = parse_opt(args[i], 'mode')
|
|
if (val) { mode = val; continue }
|
|
val = parse_opt(args[i], 'max_size')
|
|
if (val) { max_size = number(val); continue }
|
|
}
|
|
|
|
config = load_config()
|
|
if (!config) config = {}
|
|
if (!config.sink) config.sink = {}
|
|
|
|
config.sink[name] = {type: sink_type, format: format, channels: channels}
|
|
if (path) config.sink[name].path = path
|
|
if (exclude) config.sink[name].exclude = exclude
|
|
if (mode) config.sink[name].mode = mode
|
|
if (max_size) config.sink[name].max_size = max_size
|
|
|
|
save_config(config)
|
|
log.console("Added sink: " + name)
|
|
}
|
|
|
|
function do_remove() {
|
|
var name = null
|
|
var config = null
|
|
if (length(args) < 2) {
|
|
log.console("Usage: cell log remove <name>")
|
|
return
|
|
}
|
|
name = args[1]
|
|
config = load_config()
|
|
if (!config || !config.sink || !config.sink[name]) {
|
|
log.console("Sink not found: " + name)
|
|
return
|
|
}
|
|
delete config.sink[name]
|
|
save_config(config)
|
|
log.console("Removed sink: " + name)
|
|
}
|
|
|
|
function do_route() {
|
|
var channel = null
|
|
var sink_name = null
|
|
var config = null
|
|
var sink = null
|
|
var already = false
|
|
if (length(args) < 3) {
|
|
log.console("Usage: cell log route <channel> <sink>")
|
|
return
|
|
}
|
|
channel = args[1]
|
|
sink_name = args[2]
|
|
config = load_config()
|
|
if (!config || !config.sink || !config.sink[sink_name]) {
|
|
log.console("Sink not found: " + sink_name)
|
|
return
|
|
}
|
|
sink = config.sink[sink_name]
|
|
if (!is_array(sink.channels)) sink.channels = []
|
|
arrfor(sink.channels, function(ch) {
|
|
if (ch == channel) already = true
|
|
})
|
|
if (already) {
|
|
log.console(channel + " already routed to " + sink_name)
|
|
return
|
|
}
|
|
sink.channels[] = channel
|
|
save_config(config)
|
|
log.console(channel + " -> " + sink_name)
|
|
}
|
|
|
|
function do_unroute() {
|
|
var channel = null
|
|
var sink_name = null
|
|
var config = null
|
|
var sink = null
|
|
var found = false
|
|
if (length(args) < 3) {
|
|
log.console("Usage: cell log unroute <channel> <sink>")
|
|
return
|
|
}
|
|
channel = args[1]
|
|
sink_name = args[2]
|
|
config = load_config()
|
|
if (!config || !config.sink || !config.sink[sink_name]) {
|
|
log.console("Sink not found: " + sink_name)
|
|
return
|
|
}
|
|
sink = config.sink[sink_name]
|
|
if (!is_array(sink.channels)) sink.channels = []
|
|
sink.channels = filter(sink.channels, function(ch) { return ch != channel })
|
|
save_config(config)
|
|
log.console(channel + " removed from " + sink_name)
|
|
}
|
|
|
|
function do_stack() {
|
|
var channel = null
|
|
var config = null
|
|
var names = null
|
|
var added = false
|
|
if (length(args) < 2) {
|
|
log.console("Usage: cell log stack <channel>")
|
|
return
|
|
}
|
|
channel = args[1]
|
|
config = load_config()
|
|
if (!config || !config.sink) {
|
|
log.console("No sinks configured")
|
|
return
|
|
}
|
|
// Add to first sink that already has a stack array, or first sink overall
|
|
names = array(config.sink)
|
|
arrfor(names, function(n) {
|
|
var s = config.sink[n]
|
|
var already = false
|
|
if (added) return
|
|
if (is_array(s.stack)) {
|
|
arrfor(s.stack, function(ch) { if (ch == channel) already = true })
|
|
if (!already) s.stack[] = channel
|
|
added = true
|
|
}
|
|
})
|
|
if (!added && length(names) > 0) {
|
|
config.sink[names[0]].stack = [channel]
|
|
added = true
|
|
}
|
|
if (added) {
|
|
save_config(config)
|
|
log.console("Stack traces enabled on: " + channel)
|
|
}
|
|
}
|
|
|
|
function do_unstack() {
|
|
var channel = null
|
|
var config = null
|
|
var names = null
|
|
if (length(args) < 2) {
|
|
log.console("Usage: cell log unstack <channel>")
|
|
return
|
|
}
|
|
channel = args[1]
|
|
config = load_config()
|
|
if (!config || !config.sink) {
|
|
log.console("No sinks configured")
|
|
return
|
|
}
|
|
names = array(config.sink)
|
|
arrfor(names, function(n) {
|
|
var s = config.sink[n]
|
|
if (is_array(s.stack))
|
|
s.stack = filter(s.stack, function(ch) { return ch != channel })
|
|
})
|
|
save_config(config)
|
|
log.console("Stack traces disabled on: " + channel)
|
|
}
|
|
|
|
var known_channels = ["console", "error", "warn", "system", "build", "shop", "compile", "test"]
|
|
|
|
function find_terminal_sink(config) {
|
|
var names = null
|
|
var found = null
|
|
if (!config || !config.sink) return null
|
|
names = array(config.sink)
|
|
if (config.sink.terminal) return config.sink.terminal
|
|
arrfor(names, function(n) {
|
|
if (!found && config.sink[n].type == "console")
|
|
found = config.sink[n]
|
|
})
|
|
return found
|
|
}
|
|
|
|
function do_enable() {
|
|
var channel = null
|
|
var config = null
|
|
var sink = null
|
|
var i = 0
|
|
var already = false
|
|
if (length(args) < 2) {
|
|
log.error("Usage: cell log enable <channel>")
|
|
return
|
|
}
|
|
channel = args[1]
|
|
config = load_config()
|
|
if (!config) config = {sink: {}}
|
|
if (!config.sink) config.sink = {}
|
|
sink = find_terminal_sink(config)
|
|
if (!sink) {
|
|
config.sink.terminal = {type: "console", format: "clean", channels: ["console", "error", channel], stack: ["error"]}
|
|
save_config(config)
|
|
log.console("Enabled channel: " + channel)
|
|
return
|
|
}
|
|
if (is_array(sink.channels) && length(sink.channels) == 1 && sink.channels[0] == "*") {
|
|
if (is_array(sink.exclude)) {
|
|
var new_exclude = []
|
|
arrfor(sink.exclude, function(ex) {
|
|
if (ex != channel) push(new_exclude, ex)
|
|
})
|
|
sink.exclude = new_exclude
|
|
}
|
|
} else {
|
|
if (!is_array(sink.channels)) sink.channels = ["console", "error"]
|
|
arrfor(sink.channels, function(ch) {
|
|
if (ch == channel) already = true
|
|
})
|
|
if (!already) sink.channels[] = channel
|
|
}
|
|
save_config(config)
|
|
log.console("Enabled channel: " + channel)
|
|
}
|
|
|
|
function do_disable() {
|
|
var channel = null
|
|
var config = null
|
|
var sink = null
|
|
var i = 0
|
|
var new_channels = []
|
|
if (length(args) < 2) {
|
|
log.error("Usage: cell log disable <channel>")
|
|
return
|
|
}
|
|
channel = args[1]
|
|
config = load_config()
|
|
if (!config || !config.sink) {
|
|
log.error("No log configuration found")
|
|
return
|
|
}
|
|
sink = find_terminal_sink(config)
|
|
if (!sink) {
|
|
log.error("No terminal sink found")
|
|
return
|
|
}
|
|
if (is_array(sink.channels) && length(sink.channels) == 1 && sink.channels[0] == "*") {
|
|
if (!is_array(sink.exclude)) sink.exclude = []
|
|
var already_excluded = false
|
|
arrfor(sink.exclude, function(ex) {
|
|
if (ex == channel) already_excluded = true
|
|
})
|
|
if (!already_excluded) sink.exclude[] = channel
|
|
} else {
|
|
if (is_array(sink.channels)) {
|
|
arrfor(sink.channels, function(ch) {
|
|
if (ch != channel) push(new_channels, ch)
|
|
})
|
|
sink.channels = new_channels
|
|
}
|
|
}
|
|
save_config(config)
|
|
log.console("Disabled channel: " + channel)
|
|
}
|
|
|
|
function do_channels() {
|
|
var config = load_config()
|
|
var sink = null
|
|
var is_wildcard = false
|
|
var active = {}
|
|
if (config) sink = find_terminal_sink(config)
|
|
if (sink) {
|
|
if (is_array(sink.channels) && length(sink.channels) == 1 && sink.channels[0] == "*") {
|
|
is_wildcard = true
|
|
arrfor(known_channels, function(ch) { active[ch] = true })
|
|
if (is_array(sink.exclude)) {
|
|
arrfor(sink.exclude, function(ex) { active[ex] = false })
|
|
}
|
|
} else if (is_array(sink.channels)) {
|
|
arrfor(sink.channels, function(ch) { active[ch] = true })
|
|
}
|
|
} else {
|
|
active.console = true
|
|
active.error = true
|
|
}
|
|
log.console("Channels:")
|
|
arrfor(known_channels, function(ch) {
|
|
var status = active[ch] ? "enabled" : "disabled"
|
|
log.console(" " + ch + ": " + status)
|
|
})
|
|
}
|
|
|
|
// Main dispatch
|
|
if (length(args) == 0) {
|
|
print_help()
|
|
} else if (args[0] == 'help' || args[0] == '-h' || args[0] == '--help') {
|
|
print_help()
|
|
} else if (args[0] == 'list') {
|
|
do_list()
|
|
} else if (args[0] == 'channels') {
|
|
do_channels()
|
|
} else if (args[0] == 'enable') {
|
|
do_enable()
|
|
} else if (args[0] == 'disable') {
|
|
do_disable()
|
|
} else if (args[0] == 'add') {
|
|
do_add()
|
|
} else if (args[0] == 'remove') {
|
|
do_remove()
|
|
} else if (args[0] == 'route') {
|
|
do_route()
|
|
} else if (args[0] == 'unroute') {
|
|
do_unroute()
|
|
} else if (args[0] == 'stack') {
|
|
do_stack()
|
|
} else if (args[0] == 'unstack') {
|
|
do_unstack()
|
|
} else {
|
|
log.console("Unknown command: " + args[0])
|
|
print_help()
|
|
}
|
|
|
|
$stop()
|