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