feat(logs): add command to send logs

Author: vgrozdanic

src/commands/logs/common_args.rs

@@ -0,0 +1,13 @@
+use clap::Args;
+
+/// Common arguments for all logs subcommands.
+#[derive(Args)]
+pub(super) struct CommonLogsArgs {
+    #[arg(short = 'o', long = "org")]
+    #[arg(help = "The organization ID or slug.")]
+    pub(super) org: Option<String>,
+
+    #[arg(short = 'p', long = "project")]
+    #[arg(help = "The project ID or slug.")]
+    pub(super) project: Option<String>,
+}

src/commands/logs/list.rs

@@ -1,8 +1,9 @@
 use std::borrow::Cow;
 
 use anyhow::Result;
-use clap::Args;
+use clap::{command, Args};
 
+use super::common_args::CommonLogsArgs;
 use crate::api::{Api, Dataset, FetchEventsOptions};
 use crate::config::Config;
 use crate::utils::formatting::Table;
@@ -39,13 +40,8 @@ const LOG_FIELDS: &[&str] = &[
 /// Arguments for listing logs
 #[derive(Args)]
 pub(super) struct ListLogsArgs {
-    #[arg(short = 'o', long = "org")]
-    #[arg(help = "The organization ID or slug.")]
-    org: Option<String>,
-
-    #[arg(short = 'p', long = "project")]
-    #[arg(help = "The project ID or slug.")]
-    project: Option<String>,
+    #[command(flatten)]
+    common: CommonLogsArgs,
 
     #[arg(long = "max-rows", default_value = "100")]
     #[arg(value_parser = validate_max_rows)]
@@ -61,13 +57,14 @@ pub(super) fn execute(args: ListLogsArgs) -> Result<()> {
     let config = Config::current();
     let (default_org, default_project) = config.get_org_and_project_defaults();
 
-    let org = args.org.as_ref().or(default_org.as_ref()).ok_or_else(|| {
+    let org = args.common.org.as_ref().or(default_org.as_ref()).ok_or_else(|| {
         anyhow::anyhow!(
             "No organization specified. Please specify an organization using the --org argument."
         )
     })?;
 
     let project = args
+        .common
         .project
         .as_ref()
         .or(default_project.as_ref())

src/commands/logs/mod.rs

@@ -1,6 +1,9 @@
+mod common_args;
 mod list;
+mod send;
 
 use self::list::ListLogsArgs;
+use self::send::SendLogsArgs;
 use super::derive_parser::{SentryCLI, SentryCLICommand};
 use anyhow::Result;
 use clap::ArgMatches;
@@ -10,6 +13,7 @@ const BETA_WARNING: &str = "[BETA] The \"logs\" command is in beta. The command
     to breaking changes, including removal, in any Sentry CLI release.";
 
 const LIST_ABOUT: &str = "List logs from your organization";
+const SEND_ABOUT: &str = "Send a log entry to Sentry";
 
 #[derive(Args)]
 pub(super) struct LogsArgs {
@@ -32,6 +36,11 @@ enum LogsSubcommand {
     {BETA_WARNING}")
 )]
     List(ListLogsArgs),
+    #[command(about = format!("[BETA] {SEND_ABOUT}"))]
+    #[command(long_about = format!("{SEND_ABOUT}. \
+    Send a single log entry using the Sentry Logs envelope format.\n\n\
+    {BETA_WARNING}"))]
+    Send(SendLogsArgs),
 }
 
 pub(super) fn make_command(command: Command) -> Command {
@@ -47,5 +56,6 @@ pub(super) fn execute(_: &ArgMatches) -> Result<()> {
 
     match subcommand {
         LogsSubcommand::List(args) => list::execute(args),
+        LogsSubcommand::Send(args) => send::execute(args),
     }
 }

src/commands/logs/send.rs

@@ -0,0 +1,270 @@
+use anyhow::{anyhow, Result};
+use clap::Args;
+use serde::Serialize;
+use serde_json::{json, Value};
+use std::collections::HashMap;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use super::common_args::CommonLogsArgs;
+use crate::api::envelopes_api::EnvelopesApi;
+use crate::config::Config;
+use crate::utils::event::get_sdk_info;
+use crate::utils::releases::detect_release_name;
+
+#[derive(Args)]
+pub(super) struct SendLogsArgs {
+    #[command(flatten)]
+    common: CommonLogsArgs,
+
+    #[arg(long = "level", value_parser = ["trace", "debug", "info", "warn", "error", "fatal"], default_value = "info", help = "Log severity level.")]
+    level: String,
+
+    #[arg(long = "message", help = "Log message body.")]
+    message: String,
+
+    #[arg(
+        long = "trace-id",
+        value_name = "TRACE_ID",
+        required = false,
+        help = "Optional 32-char hex trace id. If omitted, a random one is generated."
+    )]
+    trace_id: Option<String>,
+
+    #[arg(
+        long = "release",
+        short = 'r',
+        value_name = "RELEASE",
+        help = "Optional release identifier. Defaults to auto-detected value."
+    )]
+    release: Option<String>,
+
+    #[arg(
+        long = "env",
+        short = 'E',
+        value_name = "ENVIRONMENT",
+        help = "Optional environment name."
+    )]
+    environment: Option<String>,
+
+    #[arg(long = "attr", short = 'a', value_name = "KEY:VALUE", action = clap::ArgAction::Append, help = "Add attributes to the log (key:value pairs). Can be used multiple times.")]
+    attributes: Vec<String>,
+}
+
+#[derive(Serialize)]
+struct LogItem<'a> {
+    timestamp: f64,
+    #[serde(rename = "trace_id")]
+    trace_id: &'a str,
+    level: &'a str,
+    #[serde(rename = "body")]
+    body: &'a str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    severity_number: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    attributes: Option<HashMap<String, AttributeValue>>,
+}
+
+#[derive(Serialize)]
+struct AttributeValue {
+    value: Value,
+    #[serde(rename = "type")]
+    attr_type: String,
+}
+
+fn level_to_severity_number(level: &str) -> i32 {
+    match level {
+        "trace" => 1,
+        "debug" => 5,
+        "info" => 9,
+        "warn" => 13,
+        "error" => 17,
+        "fatal" => 21,
+        _ => 9,
+    }
+}
+
+fn now_timestamp_seconds() -> f64 {
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("Time went backwards");
+    now.as_secs() as f64 + (now.subsec_nanos() as f64) / 1_000_000_000.0
+}
+
+fn generate_trace_id() -> String {
+    // Generate 16 random bytes, hex-encoded to 32 chars. UUID v4 is 16 random bytes.
+    let uuid = uuid::Uuid::new_v4();
+    data_encoding::HEXLOWER.encode(uuid.as_bytes())
+}
+
+fn parse_attributes(attrs: &[String]) -> Result<HashMap<String, AttributeValue>> {
+    let mut attributes = HashMap::new();
+
+    for attr in attrs {
+        let parts: Vec<&str> = attr.splitn(2, ':').collect();
+        if parts.len() != 2 {
+            return Err(anyhow!(
+                "Invalid attribute format '{}'. Expected 'key:value'",
+                attr
+            ));
+        }
+
+        let key = parts[0].to_owned();
+        let value_str = parts[1];
+
+        // Try to parse as different types
+        let (value, attr_type) = if let Ok(b) = value_str.parse::<bool>() {
+            (Value::Bool(b), "boolean".to_owned())
+        } else if let Ok(i) = value_str.parse::<i64>() {
+            (
+                Value::Number(serde_json::Number::from(i)),
+                "integer".to_owned(),
+            )
+        } else if let Ok(f) = value_str.parse::<f64>() {
+            (
+                Value::Number(serde_json::Number::from_f64(f).expect("Failed to parse float")),
+                "double".to_owned(),
+            )
+        } else {
+            (Value::String(value_str.to_owned()), "string".to_owned())
+        };
+
+        attributes.insert(key, AttributeValue { value, attr_type });
+    }
+
+    Ok(attributes)
+}
+
+fn add_sdk_attributes(attributes: &mut HashMap<String, AttributeValue>) {
+    let sdk_info = get_sdk_info();
+
+    attributes.insert(
+        "sentry.sdk.name".to_owned(),
+        AttributeValue {
+            value: Value::String(sdk_info.name.to_owned()),
+            attr_type: "string".to_owned(),
+        },
+    );
+
+    attributes.insert(
+        "sentry.sdk.version".to_owned(),
+        AttributeValue {
+            value: Value::String(sdk_info.version.to_owned()),
+            attr_type: "string".to_owned(),
+        },
+    );
+}
+
+pub(super) fn execute(args: SendLogsArgs) -> Result<()> {
+    // Get org and project from args or config defaults
+    let config = Config::current();
+    let (default_org, default_project) = config.get_org_and_project_defaults();
+
+    let _org = args
+        .common
+        .org
+        .as_ref()
+        .or(default_org.as_ref())
+        .ok_or_else(|| {
+            anyhow!(
+            "No organization specified. Please specify an organization using the --org argument."
+        )
+        })?;
+
+    let _project = args
+        .common
+        .project
+        .as_ref()
+        .or(default_project.as_ref())
+        .ok_or_else(|| {
+            anyhow!("No project specified. Use --project or set a default in config.")
+        })?;
+
+    // Note: The org and project values are currently not used for sending logs,
+    // as the EnvelopesApi uses the DSN from config which already contains this information.
+    // These arguments are kept for consistency with other commands and potential future use.
+
+    // Validate trace id or generate a new one
+    let trace_id_owned;
+    let trace_id = if let Some(tid) = &args.trace_id {
+        let is_valid = tid.len() == 32 && tid.chars().all(|c| c.is_ascii_hexdigit());
+        if !is_valid {
+            return Err(anyhow!("trace-id must be a 32-character hex string"));
+        }
+        tid.as_str()
+    } else {
+        trace_id_owned = generate_trace_id();
+        &trace_id_owned
+    };
+
+    let severity_number = level_to_severity_number(&args.level);
+
+    // Parse and build attributes
+    let mut attributes = parse_attributes(&args.attributes)?;
+
+    // Add SDK attributes
+    add_sdk_attributes(&mut attributes);
+
+    // Add release if provided or detected
+    let release = args.release.clone().or_else(|| detect_release_name().ok());
+    if let Some(rel) = &release {
+        attributes.insert(
+            "sentry.release".to_owned(),
+            AttributeValue {
+                value: Value::String(rel.clone()),
+                attr_type: "string".to_owned(),
+            },
+        );
+    }
+
+    // Add environment if provided
+    if let Some(env) = &args.environment {
+        attributes.insert(
+            "sentry.environment".to_owned(),
+            AttributeValue {
+                value: Value::String(env.clone()),
+                attr_type: "string".to_owned(),
+            },
+        );
+    }
+
+    // Build a logs envelope as raw bytes according to the Logs spec
+    let log_item = LogItem {
+        timestamp: now_timestamp_seconds(),
+        trace_id,
+        level: &args.level,
+        body: &args.message,
+        severity_number: Some(severity_number),
+        attributes: if attributes.is_empty() {
+            None
+        } else {
+            Some(attributes)
+        },
+    };
+
+    let payload = json!({
+        "items": [log_item]
+    });
+
+    let payload_bytes = serde_json::to_vec(&payload)?;
+    let header = json!({
+        "type": "log",
+        "item_count": 1,
+        "content_type": "application/vnd.sentry.items.log+json",
+        "length": payload_bytes.len()
+    });
+    let header_bytes = serde_json::to_vec(&header)?;
+
+    // Construct raw envelope: metadata line (empty for logs), then header, then payload
+    let mut buf = Vec::new();
+    // Empty envelope metadata with no event_id
+    buf.extend_from_slice(b"{}\n");
+    buf.extend_from_slice(&header_bytes);
+    buf.push(b'\n');
+    buf.extend_from_slice(&payload_bytes);
+
+    let envelope = sentry::Envelope::from_bytes_raw(buf)?;
+    EnvelopesApi::try_new()?.send_envelope(envelope)?;
+
+    println!("Log sent.");
+    Ok(())
+}

tests/integration/_cases/logs/logs-help.trycmd

@@ -10,6 +10,7 @@ Usage: sentry-cli[EXE] logs [OPTIONS] [COMMAND]
 
 Commands:
   list  [BETA] List logs from your organization
+  send  [BETA] Send a log entry to Sentry
   help  Print this message or the help of the given subcommand(s)
 
 Options: