feat: have a meaningful default for instance.id

Signed-off-by: jeluard <jeluard@users.noreply.github.com>

Author: jeluard

crates/amaru/src/bin/amaru/cmd/run.rs

@@ -130,6 +130,12 @@ pub struct Args {
     pid_file: Option<PathBuf>,
 }
 
+impl Args {
+    pub fn listen_address(&self) -> &str {
+        &self.listen_address
+    }
+}
+
 pub async fn run(args: Args, meter_provider: Option<SdkMeterProvider>) -> Result<(), Box<dyn std::error::Error>> {
     with_optional_pid_file(args.pid_file.clone(), async |_pid_file| {
         let config = parse_args(args)?;

crates/amaru/src/bin/amaru/main.rs

@@ -15,7 +15,7 @@
 use std::sync::LazyLock;
 
 use amaru::{
-    observability::{Color, setup_observability},
+    observability::{Color, ObservabilityHints, setup_observability},
     panic::panic_handler,
 };
 use clap::{CommandFactory, FromArgMatches, Parser, Subcommand};
@@ -116,6 +116,16 @@ enum Command {
     Run(cmd::run::Args),
 }
 
+impl ObservabilityHints for Command {
+    fn listen_address(&self) -> Option<&str> {
+        #[allow(clippy::wildcard_enum_match_arm)]
+        match self {
+            Command::Run(args) => Some(args.listen_address()),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Debug, Parser)]
 #[clap(name = "Amaru")]
 #[clap(bin_name = "amaru")]
@@ -151,8 +161,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let (metrics, teardown) = if skip_logging {
         (None, Box::new(|| Ok(())) as Box<dyn FnOnce() -> Result<(), Box<dyn std::error::Error>>>)
     } else {
-        let (m, t) =
-            setup_observability(args.with_open_telemetry, args.with_json_traces, Color::is_enabled(args.color));
+        let (m, t) = setup_observability(
+            args.with_open_telemetry,
+            args.with_json_traces,
+            Color::is_enabled(args.color),
+            &args.command,
+        );
         (Some(m), t)
     };
 

crates/amaru/src/bin/ledger/main.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use amaru::{
-    observability::{Color, setup_observability},
+    observability::{Color, ObservabilityHints, setup_observability},
     panic::panic_handler,
 };
 use clap::{Parser, Subcommand};
@@ -31,6 +31,13 @@ enum Command {
     #[cfg(feature = "mithril")]
     Mithril(cmd::mithril::Args),
 }
+
+impl ObservabilityHints for Command {
+    fn listen_address(&self) -> Option<&str> {
+        None
+    }
+}
+
 #[derive(Debug, Parser)]
 #[clap(name = "Amaru Ledger")]
 #[clap(bin_name = "amaru-ledger")]
@@ -61,8 +68,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         "Started with global arguments"
     );
 
-    let (_metrics, teardown) =
-        setup_observability(args.with_open_telemetry, args.with_json_traces, Color::is_enabled(args.color));
+    let (_metrics, teardown) = setup_observability(
+        args.with_open_telemetry,
+        args.with_json_traces,
+        Color::is_enabled(args.color),
+        &args.command,
+    );
 
     let result = match args.command {
         Command::Sync(args) => cmd::sync::run(args).await,

crates/amaru/src/observability.rs

@@ -270,17 +270,33 @@ impl Default for OpenTelemetryHandle {
 const DEFAULT_OTLP_SERVICE_NAME: &str = "amaru";
 const DEFAULT_OTLP_METRIC_URL: &str = "http://localhost:4318/v1/metrics";
 
+/// Context hints supplied by the caller to refine observability defaults.
+pub trait ObservabilityHints {
+    /// The address the node will listen on, if known at this point.
+    /// Used to build the default `service.instance.id` resource attribute.
+    fn listen_address(&self) -> Option<&str>;
+}
+
 #[expect(clippy::panic)]
-pub fn setup_open_telemetry(subscriber: &mut TracingSubscriber<Registry>) -> (OpenTelemetryHandle, DelayedWarning) {
+pub fn setup_open_telemetry(
+    subscriber: &mut TracingSubscriber<Registry>,
+    hints: &impl ObservabilityHints,
+) -> (OpenTelemetryHandle, DelayedWarning) {
     use opentelemetry::KeyValue;
     use opentelemetry_sdk::{Resource, metrics::Temporality};
 
     let service_name =
         var("OTEL_SERVICE_NAME").unwrap_or_else(|_| DEFAULT_OTLP_SERVICE_NAME.to_string()).trim().to_string();
-    let service_instance_id = var("OTEL_SERVICE_INSTANCE_ID").ok();
+    let service_instance_id: Option<String> =
+        var("OTEL_SERVICE_INSTANCE_ID").ok().map(|v| v.trim().to_string()).filter(|v| !v.is_empty()).or_else(|| {
+            let listen_addr = hints.listen_address()?;
+            let hostname = sysinfo::System::host_name().unwrap_or_else(|| "localhost".to_string());
+            let port = listen_addr.trim().rsplit(':').next()?;
+            Some(format!("{hostname}:{port}"))
+        });
     let mut attributes = vec![KeyValue::new(SERVICE_NAME, service_name.clone())];
-    if let Some(id) = service_instance_id.filter(|value| !value.trim().is_empty()) {
-        attributes.push(KeyValue::new(SERVICE_INSTANCE_ID, id));
+    if let Some(instance_id) = service_instance_id {
+        attributes.push(KeyValue::new(SERVICE_INSTANCE_ID, instance_id));
     }
     let resource = Resource::builder().with_attributes(attributes).build();
 
@@ -465,11 +481,12 @@ pub fn setup_observability(
     with_open_telemetry: bool,
     with_json_traces: bool,
     color: bool,
+    hints: &impl ObservabilityHints,
 ) -> (Option<SdkMeterProvider>, Box<dyn FnOnce() -> Result<(), Box<dyn std::error::Error>>>) {
     let mut subscriber = TracingSubscriber::new();
 
     let (OpenTelemetryHandle { metrics, teardown }, warning_otlp) = if with_open_telemetry {
-        setup_open_telemetry(&mut subscriber)
+        setup_open_telemetry(&mut subscriber, hints)
     } else {
         (OpenTelemetryHandle::default(), None)
     };