Migrate datadog-serverless-trace-mini-agent from libdatadog to serverless-components as datadog-serverless-compat (#9)

* Serverless Trace Mini Agent (#124)

* Mini Agent: add trace normalization, root span calculation, logging (#130)

* Mini Agent: Modify flushing logic, Serverless root span tags (#133)

* Mini Agent: Trace stats (#139)

* Mini Agent: Verify GCP Env (#142)

* Reformat License and add SPDX headers

* Make verify timeout test in datadog-trace-mini-agent trigger timeout

* Only setting the timeout to 0 ms is not enough, and there was a race
  in the test between the dns lookup and the timeout that intermittently
  failed the test (most likely on Windows).

* Enable all benchmarks

* bump versions of datadog-serverless-trace-mini-agent and datadog-trace-mini-agent to 0.5.0 (#528)

* [Serverless Mini Agent] Add _dd.mini_agent_version tag to all spans for Azure Functions, Google Cloud Functions, and Azure Spring Apps (#548)

* add _dd.mini_agent_version to spans in all environments

* apply formatting

* bump datadog-serverless-trace-mini-agent version to 0.6.0 (#555)

* [Serverless Mini Agent] bump version to 0.6.1 (#575)

* [Serverless Mini Agent] Use DogStatsD in Serverless (#616)

* use dogstatsd in serverless

* convert env var value to lowercase and nest dogstatsd logic

* refactor to move loop outside of conditional dogstatsd block

* add environment variables for hardcoded values and refactor start_dogstatsd

* fix unit test

* add env var for default dogstatsd port

* bump datadog-serverless-trace-mini-agent version to 0.7.0 (#623)

* feat: Support DD_HTTP_PROXY and DD_HTTPS_PROXY (#631)

* feat: Support DD_HTTP_PROXY and DD_HTTPS_PROXY

* fix: fmt

* feat: honor dd_proxy

* bump datadog-serverless-trace-mini-agent version to 0.7.1 (#633)

* bump datadog-serverless-trace-mini-agent version to 0.7.2 (#635)

* Upstream dogstatsd refactors (#617)

* feat: upstream dogstatsd from datadog lambda extension

* add: stand alone dogstatsd binary as example

* fix: imports

* fix: make test utils public

* fix: more test utils public

* fix: make entry public

* fix: clippy

* fix: make test config public

* Revert "fix: make test config public"

This reverts commit 7dc979979d85c665767906030f91253725850f30.

* fix: make fields public for tests and assertions

* refactor: remove unused error

* refactor: do one step parsing

* fix: duplicate dependencies from conflicts

* refactor: use type for sorted tags and ustr

* fix: statsd parsing and tests

* format: format and clippy
test: fix test format with # for tags. It also changed the byte wise
test expected result

* fix: use only minimum regexp

* fix: increase to 10k context size, lost in refactors/moving

* refactor: update license

* fix: remove custom toolchain

* style: fix comment too long not picked up by rustfmt

* fix: restore previous cargo.lock

* fix: missing error dep

* fix: use empty tags

* fix: update license

* fix: nightly rustc 1.83 format

* fix: clippy

* fix: do not use a map, support duplicate tag values

---------

Co-authored-by: Taegyun Kim <taegyun.kim@datadoghq.com>

* Support http-proxy for trace agent, remove proxy from dsd (#658)

* feat: support HTTPS_PROXY for traces

* fix: https_proxy only.

* fix: maybe native-tls works in lambda?

* feat: try rust-tls

* fix: rusttls oops

* fix: reee it's rustls why

* fix: default-features must be false

* WIP: debug log, will revert

* fix: reqwest honors system proxies, hyper doesn't seem to. Only proxy https traffic

* fix: revert hyper-proxy, just use system proxy

* fix: revert proxy, use system

* fix: revert hyper-proxy, use system proxy

* fix: revert senddata proxy change from tests

* Revert "fix: revert senddata proxy change from tests"

This reverts commit 105000853f86dd46c39914434907452d9ca05b60.

* Revert "fix: revert hyper-proxy, use system proxy"

This reverts commit d9ebdc7e3cd68f046a4e8d981ac0564b34458983.

* Revert "fix: revert proxy, use system"

This reverts commit e4a8e18c14b56f8b889aec23b40cf3ccaf511639.

* Revert "fix: revert hyper-proxy, just use system proxy"

This reverts commit f8ed3005f75bdb3a4a4fb35dc52f499206b8d2b9.

* fix: re-commit tests

* fix: fmt

* feat: license

* feat: Wrap proxy in feature flag

* fix: fmt

* fix: not sure why the arg is needed in create_send_data

* fix: no api changes for public interfaces

* fix: None

* fix: allow unused

* fix: None for update_send_results_example

* fix: remove unused error import

* bump datadog-serverless-trace-mini-agent version to 0.8.0 (#677)

* feat: Prefer DD_PROXY_HTTPS over HTTPS_PROXY (#673)

* feat: Prefer DD_PROXY_HTTPS over HTTPS_PROXY

* fix: no proxy on ints

* fix: clippy thx

* Increase DogStatsD Buffer Size and Pattern Match Container Ids (#698)

* show dogstatsd logs in serverless mini agent

* increase buffer size to 8192 bytes

* update metric pattern to exclude service checks and to account for container ids

* exclude events from being parsed

* add comment for 8KB max buffer size matching default value in Go Agent

* lazily initialize static regex for dogstatsd metrics

* minor refactors

* add unit tests

* remove explicit drops

* bump datadog-serverless-trace-mini-agent version to 0.9.0 (#723)

* Svls 6036 set timeouts (#800)

* add fixed timeout to verify behavior

* add number of series and distro to flush

* tmp: add info on trace retries

* add more tmp debug log

* fix debug log

* Revert "fix debug log"

This reverts commit 4b44bb37ec4cc658d37fbeea820d399a4e924788.

* Revert "add more tmp debug log"

This reverts commit 536917b8c2f990365058c90a580937ee5e5f1894.

* Revert "tmp: add info on trace retries"

This reverts commit 5e4790794decea0f3f7e1ab523a9ab36e39820db.

* add timeout for client

* add todo

* fmt

* add constant for timeout duration

---------

Co-authored-by: jordan gonzález <30836115+duncanista@users.noreply.github.com>

* bump datadog-serverless-trace-mini-agent version to 0.10.0 (#824)

* chore: [SVLS-5992] clearer dogstatsd Flusher API (#822)



Co-authored-by: jordan gonzález <30836115+duncanista@users.noreply.github.com>

* Rename Mini Agent Version tag to Serverless Compat Version (#830)

* add _dd.serverless_compat_version span tag

* remove _dd.mini_agent_version tag from spans

* bump datadog-serverless-trace-mini-agent to 0.11.0 (#845)

* don't set serverless compat version from binary (#872)

* bump datadog-serverless-trace-mini-agent to 0.12.0 (#873)

* [trace-mini-agent] add trace aggregator (#907)

* add `aggregator.rs`

adds an aggregator which gives batches limited by intake payload size

* update `TraceFlusher` to use the `TraceAggregator`

* make `MiniAgent` use `TraceAggregator` on `TraceFlusher`

* fmt + clippy

* add license

* ekump/APMSP-1827 add warnings for panics (#915)

Add clippy warnings and allows for panic macros to most crates

Add an extension crate for mutex in ddcommon to isolate the unwrap to one location in code to avoid the allow annotations. We aren't going to stop unwrapping mutexes anytime soon. 

Replace use of lazy_static with OnceLock for ddcommon, ddtelemetry, live-debugger, tools, sidecar

* Push retry strategy into client (#940)

(serverless) feature: Push retry strategy to libdatadog to avoid re-compressing

* Remove Serverless Specific DogStatsD Server Implementation (#973)

* remove serverless specific dogstatsd server implementation

* remove dogstatsd version from dependency

* Add origin tag to metrics emitted from mini agent (#982)

* add origin tag to metrics emitted from mini agent

* add dd.origin tag to metrics emitted from mini agent

* chore(serverless): update components to drop hashbrown v0.14 (#1013)

* rename to serverless-compat, pin dependencies with libdatadog commit hash or serverless-components path

* use trace_agent instead of datadog_trace_mini_agent

* remove version for datadog-serverless-compat

* add release profile

* add description to datadog-serverless-compat crate

---------

Co-authored-by: David Lee <thedavl2001@gmail.com>
Co-authored-by: Björn Antonsson <bjorn.antonsson@datadoghq.com>
Co-authored-by: Aleksandr Pasechnik <aleksandr.pasechnik@datadoghq.com>
Co-authored-by: AJ Stuyvenberg <astuyve@gmail.com>
Co-authored-by: alexgallotta <5581237+alexgallotta@users.noreply.github.com>
Co-authored-by: Taegyun Kim <taegyun.kim@datadoghq.com>
Co-authored-by: jordan gonzález <30836115+duncanista@users.noreply.github.com>
Co-authored-by: Edmund Kump <edmund.kump@datadoghq.com>
Co-authored-by: Levi Morrison <levi.morrison@datadoghq.com>

Author: 10 people

Cargo.lock

@@ -12,3 +12,9 @@ edition = "2021"
 license = "Apache-2.0"
 homepage = "https://github.com/DataDog/serverless-components"
 repository = "https://github.com/DataDog/serverless-components"
+
+[profile.release]
+opt-level = "z"
+lto = true
+codegen-units = 1
+strip = true

Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "datadog-serverless-compat"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+description = "Binary to run trace-agent and dogstatsd servers in Serverless environments"
+
+[dependencies]
+log = "0.4"
+env_logger = "0.10.0"
+trace-agent = { path = "../trace-agent" }
+datadog-trace-protobuf = { git = "https://github.com/DataDog/libdatadog/", rev = "3dab0bed2e144ce78c10a2378d1aff8fb5974f7d" }
+datadog-trace-utils = { git = "https://github.com/DataDog/libdatadog/", rev = "3dab0bed2e144ce78c10a2378d1aff8fb5974f7d" }
+dogstatsd = { path = "../dogstatsd", default-features = false }
+tokio = { version = "1", features = ["macros", "rt-multi-thread"]}
+tokio-util = { version = "0.7", default-features = false }
+tracing = { version = "0.1", default-features = false }
+tracing-core = { version = "0.1", default-features = false }
+tracing-subscriber = { version = "0.3", default-features = false, features = ["std", "registry", "fmt", "env-filter", "tracing-log"] }
+
+[[bin]]
+name = "datadog-serverless-compat"

crates/serverless-compat/Cargo.toml

@@ -0,0 +1,226 @@
+// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(not(test), deny(clippy::panic))]
+#![cfg_attr(not(test), deny(clippy::unwrap_used))]
+#![cfg_attr(not(test), deny(clippy::expect_used))]
+#![cfg_attr(not(test), deny(clippy::todo))]
+#![cfg_attr(not(test), deny(clippy::unimplemented))]
+
+use env_logger::Builder;
+use log::{debug, error, info};
+use std::{env, str::FromStr, sync::Arc, sync::Mutex};
+use tokio::{
+    sync::Mutex as TokioMutex,
+    time::{interval, Duration},
+};
+use tracing_subscriber::EnvFilter;
+
+use trace_agent::{
+    aggregator::TraceAggregator,
+    config, env_verifier, mini_agent, stats_flusher, stats_processor,
+    trace_flusher::{self, TraceFlusher},
+    trace_processor,
+};
+
+use datadog_trace_utils::{config_utils::read_cloud_env, trace_utils::EnvironmentType};
+
+use dogstatsd::{
+    aggregator::Aggregator as MetricsAggregator,
+    constants::CONTEXTS,
+    datadog::{MetricsIntakeUrlPrefix, RetryStrategy, Site},
+    dogstatsd::{DogStatsD, DogStatsDConfig},
+    flusher::{Flusher, FlusherConfig},
+};
+
+use dogstatsd::metric::{SortedTags, EMPTY_TAGS};
+use tokio_util::sync::CancellationToken;
+
+const DOGSTATSD_FLUSH_INTERVAL: u64 = 10;
+const DOGSTATSD_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
+const DEFAULT_DOGSTATSD_PORT: u16 = 8125;
+const AGENT_HOST: &str = "0.0.0.0";
+
+#[tokio::main]
+pub async fn main() {
+    let log_level = env::var("DD_LOG_LEVEL")
+        .map(|val| val.to_lowercase())
+        .unwrap_or("info".to_string());
+    let level_filter = log::LevelFilter::from_str(&log_level).unwrap_or(log::LevelFilter::Info);
+    Builder::new().filter_level(level_filter).init();
+
+    let (_, env_type) = match read_cloud_env() {
+        Some(value) => value,
+        None => {
+            error!("Unable to identify environment. Shutting down Mini Agent.");
+            return;
+        }
+    };
+
+    let dogstatsd_tags = match env_type {
+        EnvironmentType::CloudFunction => "origin:cloudfunction,dd.origin:cloudfunction",
+        EnvironmentType::AzureFunction => "origin:azurefunction,dd.origin:azurefunction",
+        EnvironmentType::AzureSpringApp => "origin:azurespringapp,dd.origin:azurespringapp",
+        EnvironmentType::LambdaFunction => "origin:lambda,dd.origin:lambda", // historical reasons
+    };
+
+    let dd_api_key: Option<String> = env::var("DD_API_KEY").ok();
+    let dd_dogstatsd_port: u16 = env::var("DD_DOGSTATSD_PORT")
+        .ok()
+        .and_then(|port| port.parse::<u16>().ok())
+        .unwrap_or(DEFAULT_DOGSTATSD_PORT);
+    let dd_site = env::var("DD_SITE").unwrap_or_else(|_| "datadoghq.com".to_string());
+    let dd_use_dogstatsd = env::var("DD_USE_DOGSTATSD")
+        .map(|val| val.to_lowercase() != "false")
+        .unwrap_or(true);
+
+    let https_proxy = env::var("DD_PROXY_HTTPS")
+        .or_else(|_| env::var("HTTPS_PROXY"))
+        .ok();
+    debug!("Starting serverless trace mini agent");
+
+    let env_filter = format!("h2=off,hyper=off,rustls=off,{}", log_level);
+
+    #[allow(clippy::expect_used)]
+    let subscriber = tracing_subscriber::fmt::Subscriber::builder()
+        .with_env_filter(
+            EnvFilter::try_new(env_filter).expect("could not parse log level in configuration"),
+        )
+        .with_level(true)
+        .with_thread_names(false)
+        .with_thread_ids(false)
+        .with_line_number(false)
+        .with_file(false)
+        .with_target(false)
+        .without_time()
+        .finish();
+
+    #[allow(clippy::expect_used)]
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
+    debug!("Logging subsystem enabled");
+
+    let env_verifier = Arc::new(env_verifier::ServerlessEnvVerifier::default());
+
+    let trace_processor = Arc::new(trace_processor::ServerlessTraceProcessor {});
+
+    let stats_flusher = Arc::new(stats_flusher::ServerlessStatsFlusher {});
+    let stats_processor = Arc::new(stats_processor::ServerlessStatsProcessor {});
+
+    let config = match config::Config::new() {
+        Ok(c) => Arc::new(c),
+        Err(e) => {
+            error!("Error creating config on serverless trace mini agent startup: {e}");
+            return;
+        }
+    };
+
+    let trace_aggregator = Arc::new(TokioMutex::new(TraceAggregator::default()));
+    let trace_flusher = Arc::new(trace_flusher::ServerlessTraceFlusher::new(
+        trace_aggregator,
+        Arc::clone(&config),
+    ));
+
+    let mini_agent = Box::new(mini_agent::MiniAgent {
+        config: Arc::clone(&config),
+        env_verifier,
+        trace_processor,
+        trace_flusher,
+        stats_processor,
+        stats_flusher,
+    });
+
+    tokio::spawn(async move {
+        let res = mini_agent.start_mini_agent().await;
+        if let Err(e) = res {
+            error!("Error when starting serverless trace mini agent: {e:?}");
+        }
+    });
+
+    let mut metrics_flusher = if dd_use_dogstatsd {
+        debug!("Starting dogstatsd");
+        let (_, metrics_flusher) = start_dogstatsd(
+            dd_dogstatsd_port,
+            dd_api_key,
+            dd_site,
+            https_proxy,
+            dogstatsd_tags,
+        )
+        .await;
+        info!("dogstatsd-udp: starting to listen on port {dd_dogstatsd_port}");
+        metrics_flusher
+    } else {
+        info!("dogstatsd disabled");
+        None
+    };
+
+    let mut flush_interval = interval(Duration::from_secs(DOGSTATSD_FLUSH_INTERVAL));
+    flush_interval.tick().await; // discard first tick, which is instantaneous
+
+    loop {
+        flush_interval.tick().await;
+
+        if let Some(metrics_flusher) = metrics_flusher.as_mut() {
+            debug!("Flushing dogstatsd metrics");
+            metrics_flusher.flush().await;
+        }
+    }
+}
+
+async fn start_dogstatsd(
+    port: u16,
+    dd_api_key: Option<String>,
+    dd_site: String,
+    https_proxy: Option<String>,
+    dogstatsd_tags: &str,
+) -> (CancellationToken, Option<Flusher>) {
+    #[allow(clippy::expect_used)]
+    let metrics_aggr = Arc::new(Mutex::new(
+        MetricsAggregator::new(
+            SortedTags::parse(dogstatsd_tags).unwrap_or(EMPTY_TAGS),
+            CONTEXTS,
+        )
+        .expect("Failed to create metrics aggregator"),
+    ));
+
+    let dogstatsd_config = DogStatsDConfig {
+        host: AGENT_HOST.to_string(),
+        port,
+    };
+    let dogstatsd_cancel_token = tokio_util::sync::CancellationToken::new();
+    let dogstatsd_client = DogStatsD::new(
+        &dogstatsd_config,
+        Arc::clone(&metrics_aggr),
+        dogstatsd_cancel_token.clone(),
+    )
+    .await;
+
+    tokio::spawn(async move {
+        dogstatsd_client.spin().await;
+    });
+
+    let metrics_flusher = match dd_api_key {
+        Some(dd_api_key) => {
+            #[allow(clippy::expect_used)]
+            let metrics_flusher = Flusher::new(FlusherConfig {
+                api_key: dd_api_key,
+                aggregator: Arc::clone(&metrics_aggr),
+                metrics_intake_url_prefix: MetricsIntakeUrlPrefix::new(
+                    Some(Site::new(dd_site).expect("Failed to parse site")),
+                    None,
+                )
+                .expect("Failed to create intake URL prefix"),
+                https_proxy,
+                timeout: DOGSTATSD_TIMEOUT_DURATION,
+                retry_strategy: RetryStrategy::LinearBackoff(3, 1),
+            });
+            Some(metrics_flusher)
+        }
+        None => {
+            error!("DD_API_KEY not set, won't flush metrics");
+            None
+        }
+    };
+
+    (dogstatsd_cancel_token, metrics_flusher)
+}