liz/veilid
1
0
Fork 0
Code Pull Requests Packages Releases Activity

update

Browse Source
This commit is contained in:
John Smith
2022-06-11 18:47:58 -04:00
parent 3f7dfa6c6a
commit bcc1bfc1a3
13 changed files with 1244 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
veilid-server/Cargo.toml
View File

@@ -14,6 +14,9 @@ path = "src/main.rs"
tracing = { version = "^0", features = ["log", "attributes"] }
tracing-subscriber = { version = "^0", features = ["env-filter"] }
tracing-appender = "^0"
tracing-opentelemetry = "^0"
opentelemetry = { version = "^0", features = ["rt-async-std"] }
opentelemetry-otlp = { version = "^0", features = ["grpc-sys"] }
clap = "^3"
async-std = { version = "^1", features = ["unstable"] }
async-tungstenite = { version = "^0", features = ["async-std-runtime", "async-tls"] }

21
veilid-server/src/cmdline.rs
View File

@@ -61,6 +61,14 @@ fn do_clap_matches(default_config_path: &OsStr) -> Result<clap::ArgMatches, clap
.conflicts_with("debug")
.help("Turn on trace logging on the terminal"),
)
.arg(
Arg::new("otlp")
.long("otlp")
.takes_value(true)
.value_name("endpoint")
.default_missing_value("http://localhost:4317")
.help("Turn on OpenTelemetry tracing"),
)
.arg(
Arg::new("subnode-index")
.long("subnode-index")
@@ -197,6 +205,19 @@ pub fn process_command_line() -> Result<(Settings, ArgMatches), String> {
settingsrw.logging.terminal.enabled = true;
settingsrw.logging.terminal.level = LogLevel::Trace;
}
if matches.occurrences_of("otlp") != 0 {
settingsrw.logging.otlp.enabled = true;
settingsrw.logging.otlp.grpc_endpoint = Some(
ParsedUrl::from_str(
&matches
.value_of("otlp")
.expect("should not be null because of default missing value")
.to_string(),
)
.map_err(|e| format!("failed to parse OTLP url: {}", e))?,
);
settingsrw.logging.otlp.level = LogLevel::Trace;
}
if matches.is_present("attach") {
settingsrw.auto_attach = !matches!(matches.value_of("attach"), Some("true"));
}

35
veilid-server/src/main.rs
View File

@@ -58,18 +58,21 @@ fn main() -> Result<(), String> {
// Handle non-normal server modes
if !matches!(server_mode, ServerMode::Normal) {
// Init combined console/file logger
let _logs = VeilidLogs::setup(settings.clone())?;
// run the server to set the node id and quit
return task::block_on(async { run_veilid_server(settings, server_mode).await })
.map(|v| {
println!("{}", success);
v
})
.map_err(|e| {
println!("{}", failure);
e
});
return task::block_on(async {
// Init combined console/file logger
let _logs = VeilidLogs::setup(settings.clone())?;
run_veilid_server(settings, server_mode).await
})
.map(|v| {
println!("{}", success);
v
})
.map_err(|e| {
println!("{}", failure);
e
});
}
// --- Daemon Mode ----
@@ -83,9 +86,6 @@ fn main() -> Result<(), String> {
}
}
// Init combined console/file logger
let _logs = VeilidLogs::setup(settings.clone())?;
// --- Normal Startup ---
ctrlc::set_handler(move || {
shutdown();
@@ -93,5 +93,10 @@ fn main() -> Result<(), String> {
.expect("Error setting Ctrl-C handler");
// Run the server loop
task::block_on(async { run_veilid_server(settings, server_mode).await })
task::block_on(async {
// Init combined console/file logger
let _logs = VeilidLogs::setup(settings.clone())?;
run_veilid_server(settings, server_mode).await
})
}

21
veilid-server/src/settings.rs
View File

@@ -36,6 +36,10 @@ logging:
api:
enabled: false
level: 'info'
otlp:
enabled: false
level: 'trace'
grpc_endpoint: 'http://localhost:4317'
testing:
subnode_index: 0
core:
@@ -427,6 +431,13 @@ pub struct Api {
pub level: LogLevel,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct Otlp {
pub enabled: bool,
pub level: LogLevel,
pub grpc_endpoint: Option<ParsedUrl>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ClientApi {
pub enabled: bool,
@@ -439,6 +450,7 @@ pub struct Logging {
pub terminal: Terminal,
pub file: File,
pub api: Api,
pub otlp: Otlp,
}
#[derive(Debug, Deserialize, Serialize)]
@@ -889,6 +901,9 @@ impl Settings {
set_config_value!(inner.logging.file.level, value);
set_config_value!(inner.logging.api.enabled, value);
set_config_value!(inner.logging.api.level, value);
set_config_value!(inner.logging.otlp.enabled, value);
set_config_value!(inner.logging.otlp.level, value);
set_config_value!(inner.logging.otlp.grpc_endpoint, value);
set_config_value!(inner.testing.subnode_index, value);
set_config_value!(inner.core.protected_store.allow_insecure_fallback, value);
set_config_value!(
@@ -1404,6 +1419,12 @@ mod tests {
assert_eq!(s.logging.file.level, LogLevel::Info);
assert_eq!(s.logging.api.enabled, false);
assert_eq!(s.logging.api.level, LogLevel::Info);
assert_eq!(s.logging.otlp.enabled, false);
assert_eq!(s.logging.otlp.level, LogLevel::Trace);
assert_eq!(
s.logging.otlp.grpc_endpoint,
Some(ParsedUrl::from_str("http://127.0.0.1:4317").unwrap())
);
assert_eq!(s.testing.subnode_index, 0);
assert_eq!(

16
veilid-server/src/unix.rs
View File

@@ -95,16 +95,16 @@ pub fn run_daemon(settings: Settings, _matches: ArgMatches) -> Result<(), String
daemon
};
// Init combined console/file logger
let _logs = VeilidLogs::setup(settings.clone())?;
// Daemonize
daemon
.start()
.map_err(|e| format!("Failed to daemonize: {}", e))?;
// Now, run the server
task::block_on(async {
// Init combined console/file logger
let _logs = VeilidLogs::setup(settings.clone())?;
// Daemonize
daemon
.start()
.map_err(|e| format!("Failed to daemonize: {}", e))?;
// Catch signals
let signals = Signals::new(&[SIGHUP, SIGTERM, SIGINT, SIGQUIT])
.map_err(|e| format!("failed to init signals: {}", e))?;

44
veilid-server/src/veilid_logs.rs
View File

@@ -1,5 +1,6 @@
use crate::settings::*;
use cfg_if::*;
use opentelemetry_otlp::WithExportConfig;
use std::path::*;
use tracing::*;
use tracing_appender::*;
@@ -34,6 +35,7 @@ impl VeilidLogs {
let subscriber = Registry::default();
// Terminal logger
let subscriber = subscriber.with(if settingsr.logging.terminal.enabled {
let terminal_max_log_level: level_filters::LevelFilter =
convert_loglevel(settingsr.logging.terminal.level)
@@ -53,6 +55,46 @@ impl VeilidLogs {
None
});
// OpenTelemetry logger
let subscriber = subscriber.with(if settingsr.logging.otlp.enabled {
let otlp_max_log_level: level_filters::LevelFilter =
convert_loglevel(settingsr.logging.otlp.level)
.to_tracing_level()
.into();
let grpc_endpoint = match &settingsr.logging.otlp.grpc_endpoint {
Some(v) => &v.urlstring,
None => {
return Err("missing OTLP GRPC endpoint url".to_owned());
}
};
// Required for GRPC dns resolution to work
std::env::set_var("GRPC_DNS_RESOLVER", "native");
let tracer = opentelemetry_otlp::new_pipeline()
.tracing()
.with_exporter(
opentelemetry_otlp::new_exporter()
.grpcio()
.with_endpoint(grpc_endpoint),
)
.install_batch(opentelemetry::runtime::AsyncStd)
.map_err(|e| format!("failed to install OpenTelemetry tracer: {}", e))?;
let ignore_list = ignore_list.clone();
Some(
tracing_opentelemetry::layer()
.with_tracer(tracer)
.with_filter(otlp_max_log_level)
.with_filter(filter::FilterFn::new(move |metadata| {
logfilter(metadata, &ignore_list)
})),
)
} else {
None
});
// File logger
let mut guard = None;
let subscriber = subscriber.with(if settingsr.logging.file.enabled {
let file_max_log_level: level_filters::LevelFilter =
@@ -98,6 +140,7 @@ impl VeilidLogs {
None
});
// API logger
let subscriber = subscriber.with(if settingsr.logging.api.enabled {
// Get layer from veilid core, filtering is done by ApiTracingLayer automatically
Some(veilid_core::ApiTracingLayer::get())
@@ -105,6 +148,7 @@ impl VeilidLogs {
None
});
// Systemd Journal logger
cfg_if! {
if #[cfg(target_os = "linux")] {
let subscriber = subscriber.with(if settingsr.logging.system.enabled {