1mod api;
2mod auth;
3mod db;
4mod env;
5mod rpc;
6
7use axum::{body::Body, Router};
8use collab::{Error, Result};
9use db::{Db, PostgresDb};
10use serde::Deserialize;
11use std::{
12 net::{SocketAddr, TcpListener},
13 sync::Arc,
14};
15use tracing_log::LogTracer;
16use tracing_subscriber::{filter::EnvFilter, fmt::format::JsonFields, Layer};
17use util::ResultExt;
18
19#[derive(Default, Deserialize)]
20pub struct Config {
21 pub http_port: u16,
22 pub database_url: String,
23 pub api_token: String,
24 pub invite_link_prefix: String,
25 pub honeycomb_api_key: Option<String>,
26 pub honeycomb_dataset: Option<String>,
27 pub rust_log: Option<String>,
28 pub log_json: Option<bool>,
29}
30
31pub struct AppState {
32 db: Arc<dyn Db>,
33 api_token: String,
34 invite_link_prefix: String,
35}
36
37impl AppState {
38 async fn new(config: &Config) -> Result<Arc<Self>> {
39 let db = PostgresDb::new(&config.database_url, 5).await?;
40 let this = Self {
41 db: Arc::new(db),
42 api_token: config.api_token.clone(),
43 invite_link_prefix: config.invite_link_prefix.clone(),
44 };
45 Ok(Arc::new(this))
46 }
47}
48
49#[tokio::main]
50async fn main() -> Result<()> {
51 if let Err(error) = env::load_dotenv() {
52 eprintln!(
53 "error loading .env.toml (this is expected in production): {}",
54 error
55 );
56 }
57
58 let config = envy::from_env::<Config>().expect("error loading config");
59 init_tracing(&config);
60 let state = AppState::new(&config).await?;
61
62 let listener = TcpListener::bind(&format!("0.0.0.0:{}", config.http_port))
63 .expect("failed to bind TCP listener");
64 let rpc_server = rpc::Server::new(state.clone(), None);
65
66 let app = Router::<Body>::new()
67 .merge(api::routes(&rpc_server, state.clone()))
68 .merge(rpc::routes(rpc_server));
69
70 axum::Server::from_tcp(listener)?
71 .serve(app.into_make_service_with_connect_info::<SocketAddr>())
72 .await?;
73
74 Ok(())
75}
76
77pub fn init_tracing(config: &Config) -> Option<()> {
78 use opentelemetry::KeyValue;
79 use opentelemetry_otlp::WithExportConfig;
80 use std::str::FromStr;
81 use tracing_opentelemetry::OpenTelemetryLayer;
82 use tracing_subscriber::layer::SubscriberExt;
83 let rust_log = config.rust_log.clone()?;
84
85 LogTracer::init().log_err()?;
86
87 let open_telemetry_layer = config
88 .honeycomb_api_key
89 .clone()
90 .zip(config.honeycomb_dataset.clone())
91 .map(|(honeycomb_api_key, honeycomb_dataset)| {
92 let mut metadata = tonic::metadata::MetadataMap::new();
93 metadata.insert("x-honeycomb-team", honeycomb_api_key.parse().unwrap());
94 let tracer = opentelemetry_otlp::new_pipeline()
95 .tracing()
96 .with_exporter(
97 opentelemetry_otlp::new_exporter()
98 .tonic()
99 .with_endpoint("https://api.honeycomb.io")
100 .with_metadata(metadata),
101 )
102 .with_trace_config(opentelemetry::sdk::trace::config().with_resource(
103 opentelemetry::sdk::Resource::new(vec![KeyValue::new(
104 "service.name",
105 honeycomb_dataset,
106 )]),
107 ))
108 .install_batch(opentelemetry::runtime::Tokio)
109 .expect("failed to initialize tracing");
110
111 OpenTelemetryLayer::new(tracer)
112 });
113
114 let subscriber = tracing_subscriber::Registry::default()
115 .with(open_telemetry_layer)
116 .with(if config.log_json.unwrap_or(false) {
117 Box::new(
118 tracing_subscriber::fmt::layer()
119 .fmt_fields(JsonFields::default())
120 .event_format(
121 tracing_subscriber::fmt::format()
122 .json()
123 .flatten_event(true)
124 .with_span_list(true),
125 ),
126 ) as Box<dyn Layer<_> + Send + Sync>
127 } else {
128 Box::new(
129 tracing_subscriber::fmt::layer()
130 .event_format(tracing_subscriber::fmt::format().pretty()),
131 )
132 })
133 .with(EnvFilter::from_str(rust_log.as_str()).log_err()?);
134
135 tracing::subscriber::set_global_default(subscriber).unwrap();
136
137 None
138}