Struct datadog_api_client::datadogV1::api::api_logs::LogsAPI

pub struct LogsAPI { /* private fields */ }

Search your logs and send them to your Datadog platform over HTTP. See the Log Management page for more information.

Implementations

impl LogsAPI

pub fn new() -> Self

pub fn with_config(config: Configuration) -> Self

Examples found in repository

examples/v1_logs_SubmitLog.rs (line 14)

async fn main() {
    let body = vec![HTTPLogItem::new("Example-Log".to_string())
        .ddtags("host:ExampleLog".to_string())
        .additional_properties(BTreeMap::from([]))];
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api
        .submit_log(body, SubmitLogOptionalParams::default())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_logs_SubmitLog_1920474053.rs (line 15)

async fn main() {
    let body = vec![HTTPLogItem::new("Example-Log".to_string())
        .ddtags("host:ExampleLog".to_string())
        .additional_properties(BTreeMap::from([]))];
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api
        .submit_log(
            body,
            SubmitLogOptionalParams::default().content_encoding(ContentEncoding::GZIP),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_logs_SubmitLog_3418823904.rs (line 16)

async fn main() {
    let body = vec![HTTPLogItem::new("Example-Log".to_string())
        .ddtags("host:ExampleLog".to_string())
        .additional_properties(BTreeMap::from([]))];
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api
        .submit_log(
            body,
            SubmitLogOptionalParams::default().content_encoding(ContentEncoding::DEFLATE),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_logs_ListLogs.rs (line 23)

async fn main() {
    let body = LogsListRequest::new(LogsListRequestTime::new(
        DateTime::parse_from_rfc3339("2020-02-02T02:02:02.202000+00:00")
            .expect("Failed to parse datetime")
            .with_timezone(&Utc),
        DateTime::parse_from_rfc3339("2020-02-20T02:02:02.202000+00:00")
            .expect("Failed to parse datetime")
            .with_timezone(&Utc),
    ))
    .index("retention-3,retention-15".to_string())
    .query("service:web* AND @http.status_code:[200 TO 299]".to_string())
    .sort(LogsSort::TIME_ASCENDING);
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api.list_logs(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_logs_ListLogs_235998668.rs (line 26)

async fn main() {
    let body = LogsListRequest::new(
        LogsListRequestTime::new(
            DateTime::parse_from_rfc3339("2021-11-11T10:11:11+00:00")
                .expect("Failed to parse datetime")
                .with_timezone(&Utc),
            DateTime::parse_from_rfc3339("2021-11-11T11:11:11+00:00")
                .expect("Failed to parse datetime")
                .with_timezone(&Utc),
        )
        .timezone("Europe/Paris".to_string()),
    )
    .index("main".to_string())
    .query("host:Test*".to_string())
    .sort(LogsSort::TIME_ASCENDING);
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api.list_logs(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn with_client_and_config( config: Configuration, client: ClientWithMiddleware, ) -> Self

pub async fn list_logs( &self, body: LogsListRequest, ) -> Result<LogsListResponse, Error<ListLogsError>>

List endpoint returns logs that match a log search query. Results are paginated.

If you are considering archiving logs for your organization, consider use of the Datadog archive capabilities instead of the log list API. See Datadog Logs Archive documentation.

Examples found in repository

examples/v1_logs_ListLogs.rs (line 24)

async fn main() {
    let body = LogsListRequest::new(LogsListRequestTime::new(
        DateTime::parse_from_rfc3339("2020-02-02T02:02:02.202000+00:00")
            .expect("Failed to parse datetime")
            .with_timezone(&Utc),
        DateTime::parse_from_rfc3339("2020-02-20T02:02:02.202000+00:00")
            .expect("Failed to parse datetime")
            .with_timezone(&Utc),
    ))
    .index("retention-3,retention-15".to_string())
    .query("service:web* AND @http.status_code:[200 TO 299]".to_string())
    .sort(LogsSort::TIME_ASCENDING);
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api.list_logs(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_logs_ListLogs_235998668.rs (line 27)

async fn main() {
    let body = LogsListRequest::new(
        LogsListRequestTime::new(
            DateTime::parse_from_rfc3339("2021-11-11T10:11:11+00:00")
                .expect("Failed to parse datetime")
                .with_timezone(&Utc),
            DateTime::parse_from_rfc3339("2021-11-11T11:11:11+00:00")
                .expect("Failed to parse datetime")
                .with_timezone(&Utc),
        )
        .timezone("Europe/Paris".to_string()),
    )
    .index("main".to_string())
    .query("host:Test*".to_string())
    .sort(LogsSort::TIME_ASCENDING);
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api.list_logs(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_logs_with_http_info( &self, body: LogsListRequest, ) -> Result<ResponseContent<LogsListResponse>, Error<ListLogsError>>

List endpoint returns logs that match a log search query. Results are paginated.

If you are considering archiving logs for your organization, consider use of the Datadog archive capabilities instead of the log list API. See Datadog Logs Archive documentation.

pub async fn submit_log( &self, body: Vec<HTTPLogItem>, params: SubmitLogOptionalParams, ) -> Result<BTreeMap<String, Value>, Error<SubmitLogError>>

Send your logs to your Datadog platform over HTTP. Limits per HTTP request are:

• Maximum content size per payload (uncompressed): 5MB
• Maximum size for a single log: 1MB
• Maximum array size if sending multiple logs in an array: 1000 entries

Any log exceeding 1MB is accepted and truncated by Datadog:

• For a single log request, the API truncates the log at 1MB and returns a 2xx.
• For a multi-logs request, the API processes all logs, truncates only logs larger than 1MB, and returns a 2xx.

Datadog recommends sending your logs compressed. Add the Content-Encoding: gzip header to the request when sending compressed logs.

The status codes answered by the HTTP API are:

• 200: OK
• 400: Bad request (likely an issue in the payload formatting)
• 403: Permission issue (likely using an invalid API Key)
• 413: Payload too large (batch is above 5MB uncompressed)
• 5xx: Internal error, request should be retried after some time

Examples found in repository

examples/v1_logs_SubmitLog.rs (line 16)

async fn main() {
    let body = vec![HTTPLogItem::new("Example-Log".to_string())
        .ddtags("host:ExampleLog".to_string())
        .additional_properties(BTreeMap::from([]))];
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api
        .submit_log(body, SubmitLogOptionalParams::default())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_logs_SubmitLog_1920474053.rs (lines 17-20)

async fn main() {
    let body = vec![HTTPLogItem::new("Example-Log".to_string())
        .ddtags("host:ExampleLog".to_string())
        .additional_properties(BTreeMap::from([]))];
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api
        .submit_log(
            body,
            SubmitLogOptionalParams::default().content_encoding(ContentEncoding::GZIP),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_logs_SubmitLog_3418823904.rs (lines 18-21)

async fn main() {
    let body = vec![HTTPLogItem::new("Example-Log".to_string())
        .ddtags("host:ExampleLog".to_string())
        .additional_properties(BTreeMap::from([]))];
    let configuration = datadog::Configuration::new();
    let api = LogsAPI::with_config(configuration);
    let resp = api
        .submit_log(
            body,
            SubmitLogOptionalParams::default().content_encoding(ContentEncoding::DEFLATE),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn submit_log_with_http_info( &self, body: Vec<HTTPLogItem>, params: SubmitLogOptionalParams, ) -> Result<ResponseContent<BTreeMap<String, Value>>, Error<SubmitLogError>>

Send your logs to your Datadog platform over HTTP. Limits per HTTP request are:

• Maximum content size per payload (uncompressed): 5MB
• Maximum size for a single log: 1MB
• Maximum array size if sending multiple logs in an array: 1000 entries

Any log exceeding 1MB is accepted and truncated by Datadog:

• For a single log request, the API truncates the log at 1MB and returns a 2xx.
• For a multi-logs request, the API processes all logs, truncates only logs larger than 1MB, and returns a 2xx.

Datadog recommends sending your logs compressed. Add the Content-Encoding: gzip header to the request when sending compressed logs.

The status codes answered by the HTTP API are:

• 200: OK
• 400: Bad request (likely an issue in the payload formatting)
• 403: Permission issue (likely using an invalid API Key)
• 413: Payload too large (batch is above 5MB uncompressed)
• 5xx: Internal error, request should be retried after some time

Trait Implementations

impl Clone for LogsAPI

fn clone(&self) -> LogsAPI

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LogsAPI

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LogsAPI

fn default() -> Self

Returns the “default value” for a type.