init

Author: BohuTANG

Cargo.lock

@@ -114,6 +114,7 @@ members = [
     "src/bendsave",
     "src/bendpy",
     "src/meta/app-storage",
+    "src/common/telemetry",
 ]
 
 # Workspace dependencies
@@ -188,6 +189,7 @@ databend-common-storages-stage = { path = "src/query/storages/stage" }
 databend-common-storages-stream = { path = "src/query/storages/stream" }
 databend-common-storages-system = { path = "src/query/storages/system" }
 databend-common-storages-view = { path = "src/query/storages/view" }
+databend-common-telemetry = { path = "src/common/telemetry" }
 databend-common-tracing = { path = "src/common/tracing" }
 databend-common-users = { path = "src/query/users" }
 databend-common-vector = { path = "src/common/vector" }

Cargo.toml

@@ -59,6 +59,7 @@ pub fn add_building_env_vars() {
     add_env_version();
     add_env_license();
     add_license_public_key();
+    add_env_telemetry();
 }
 
 pub fn set_env_config() {
@@ -103,6 +104,17 @@ pub fn add_license_public_key() {
     println!("cargo:rustc-env=DATABEND_ENTERPRISE_LICENSE_PUBLIC_KEY={v}");
 }
 
+pub fn add_env_telemetry() {
+    println!("cargo:rerun-if-env-changed=DATABEND_TELEMETRY_ENDPOINT");
+    let endpoint = env::var("DATABEND_TELEMETRY_ENDPOINT")
+        .unwrap_or_else(|_| "https://telemetry.databend.com/v1/report".to_string());
+    println!("cargo:rustc-env=DATABEND_TELEMETRY_ENDPOINT={endpoint}");
+
+    println!("cargo:rerun-if-env-changed=DATABEND_TELEMETRY_API_KEY");
+    let api_key = env::var("DATABEND_TELEMETRY_API_KEY").unwrap_or_default();
+    println!("cargo:rustc-env=DATABEND_TELEMETRY_API_KEY={api_key}");
+}
+
 pub fn add_env_commit_authors(repo: &Repository) {
     match git::get_commit_authors(repo) {
         Ok(authors) => println!("cargo:rustc-env=DATABEND_COMMIT_AUTHORS={}", authors),

src/common/building/src/lib.rs

@@ -0,0 +1,13 @@
+[package]
+name = "databend-common-telemetry"
+version = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+publish = { workspace = true }
+edition = { workspace = true }
+
+[dependencies]
+databend-common-version = { workspace = true }
+reqwest = { workspace = true, features = ["json", "rustls-tls"] }
+serde_json = { workspace = true }
+tokio = { workspace = true }

src/common/telemetry/Cargo.toml

@@ -0,0 +1,17 @@
+// Copyright 2021 Datafuse Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub mod simple;
+
+pub use simple::report_node_telemetry;

src/common/telemetry/src/lib.rs

@@ -0,0 +1,49 @@
+// Copyright 2021 Datafuse Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::time::Duration;
+
+use databend_common_version::DATABEND_TELEMETRY_API_KEY;
+use databend_common_version::DATABEND_TELEMETRY_ENDPOINT;
+
+pub async fn report_node_telemetry(payload: serde_json::Value) {
+    let client = match reqwest::Client::builder()
+        .timeout(Duration::from_secs(3))
+        .connect_timeout(Duration::from_secs(2))
+        .build()
+    {
+        Ok(client) => client,
+        Err(_) => return,
+    };
+
+    let version = payload
+        .get("version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown");
+
+    let mut request = client
+        .post(DATABEND_TELEMETRY_ENDPOINT)
+        .header("Content-Type", "application/json")
+        .header("User-Agent", format!("Databend/{}", version));
+
+    #[allow(clippy::const_is_empty)]
+    if !DATABEND_TELEMETRY_API_KEY.is_empty() {
+        request = request.header(
+            "Authorization",
+            format!("Bearer {}", DATABEND_TELEMETRY_API_KEY),
+        );
+    }
+
+    let _ = tokio::time::timeout(Duration::from_secs(3), request.json(&payload).send()).await;
+}

src/common/telemetry/src/simple.rs

@@ -46,6 +46,10 @@ pub const DATABEND_ENTERPRISE_LICENSE_PUBLIC_KEY: &str =
 
 pub const DATABEND_CARGO_CFG_TARGET_FEATURE: &str = env!("DATABEND_CARGO_CFG_TARGET_FEATURE");
 
+pub const DATABEND_TELEMETRY_ENDPOINT: &str = env!("DATABEND_TELEMETRY_ENDPOINT");
+
+pub const DATABEND_TELEMETRY_API_KEY: &str = env!("DATABEND_TELEMETRY_API_KEY");
+
 pub static DATABEND_SEMVER: LazyLock<Version> = LazyLock::new(|| {
     let build_semver = DATABEND_GIT_SEMVER;
     let semver = build_semver.expect("DATABEND_GIT_SEMVER can not be None");

src/common/version/src/lib.rs

@@ -48,6 +48,7 @@ use databend_common_tracing::FileConfig as InnerFileLogConfig;
 use databend_common_tracing::HistoryConfig as InnerHistoryConfig;
 use databend_common_tracing::HistoryTableConfig as InnerHistoryTableConfig;
 use databend_common_tracing::OTLPConfig as InnerOTLPLogConfig;
+// TelemetryConfig moved here to avoid circular dependency
 use databend_common_tracing::OTLPEndpointConfig as InnerOTLPEndpointConfig;
 use databend_common_tracing::OTLPProtocol;
 use databend_common_tracing::ProfileLogConfig as InnerProfileLogConfig;
@@ -63,6 +64,39 @@ use serfig::collectors::from_env;
 use serfig::collectors::from_file;
 use serfig::collectors::from_self;
 
+/// Telemetry configuration for node information reporting
+///
+/// Note: The `enabled` flag only works with Enterprise Edition license.
+/// Without EE license, telemetry is always enabled.
+/// With EE license, users can set `enabled=false` to disable telemetry reporting.
+/// The endpoint is fixed and not configurable by users.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Args)]
+#[serde(default)]
+pub struct TelemetryConfig {
+    /// Enable/disable telemetry reporting (only works with EE license)
+    #[clap(long = "telemetry-enabled", value_name = "BOOL")]
+    #[serde(default = "default_telemetry_enabled")]
+    pub enabled: bool,
+}
+
+fn default_telemetry_enabled() -> bool {
+    true
+}
+
+impl Default for TelemetryConfig {
+    fn default() -> Self {
+        Self {
+            enabled: default_telemetry_enabled(),
+        }
+    }
+}
+
+impl TelemetryConfig {
+    pub fn is_enabled(&self) -> bool {
+        self.enabled
+    }
+}
+
 use super::inner;
 use super::inner::CatalogConfig as InnerCatalogConfig;
 use super::inner::CatalogHiveConfig as InnerCatalogHiveConfig;
@@ -128,6 +162,10 @@ pub struct Config {
     #[clap(flatten)]
     pub spill: SpillConfig,
 
+    // telemetry Config
+    #[clap(flatten)]
+    pub telemetry: TelemetryConfig,
+
     /// external catalog config.
     ///
     /// - Later, catalog information SHOULD be kept in KV Service
@@ -3582,6 +3620,7 @@ mod cache_config_converters {
                     .collect(),
                 cache: inner.cache.into(),
                 spill: inner.spill.into(),
+                telemetry: inner.telemetry,
             }
         }
     }
@@ -3599,6 +3638,7 @@ mod cache_config_converters {
                 catalog,
                 cache,
                 spill,
+                telemetry,
                 catalogs: input_catalogs,
                 ..
             } = self;
@@ -3628,6 +3668,7 @@ mod cache_config_converters {
                 catalogs,
                 cache: cache.try_into()?,
                 spill,
+                telemetry,
             })
         }
     }

src/query/config/src/config.rs

@@ -37,6 +37,7 @@ use databend_common_tracing::Config as LogConfig;
 
 use super::config::Config;
 use super::config::ResourcesManagementConfig;
+use super::config::TelemetryConfig;
 use crate::BuiltInConfig;
 
 /// Inner config for query.
@@ -67,6 +68,9 @@ pub struct InnerConfig {
 
     // Spill Config
     pub spill: SpillConfig,
+
+    // Telemetry Config
+    pub telemetry: TelemetryConfig,
 }
 
 impl InnerConfig {

src/query/config/src/inner.rs

@@ -51,6 +51,7 @@ impl Config {
             catalog: self.catalog,
             cache: self.cache,
             spill: self.spill.mask_display(),
+            telemetry: self.telemetry,
             catalogs: self.catalogs,
         }
     }