// This file is part of Substrate.

// Copyright (C) Parity Technologies (UK) Ltd.

// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <https://www.gnu.org/licenses/>.

//! Substrate's client telemetry is a part of substrate that allows ingesting telemetry data

//! with for example [Polkadot telemetry](https://github.com/paritytech/substrate-telemetry).

//!

//! It works using Tokio's [tracing](https://github.com/tokio-rs/tracing/) library. The telemetry

//! information uses tracing's logging to report the telemetry data which is then retrieved by a

//! tracing `Layer`. This layer will then send the data through an asynchronous channel to a

//! background task called [`TelemetryWorker`] which will send the information to the configured

//! remote telemetry servers.

//!

//! If multiple substrate nodes are running in the same process, it uses a `tracing::Span` to

//! identify which substrate node is reporting the telemetry. Every task spawned using sc-service's

//! `TaskManager` automatically inherit this span.

//!

//! Substrate's nodes initialize/register with the [`TelemetryWorker`] using a

//! [`TelemetryWorkerHandle`]. This handle can be cloned and passed around. It uses an asynchronous

//! channel to communicate with the running [`TelemetryWorker`] dedicated to registration.

//! Registering can happen at any point in time during the process execution.

#![warn(missing_docs)]

use futures::{channel::mpsc, prelude::*};

use libp2p::Multiaddr;

use log::{error, warn};

use parking_lot::Mutex;

use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};

use serde::Serialize;

use std::{

	collections::{

		hash_map::Entry::{Occupied, Vacant},

		HashMap,

	},

	sync::{atomic, Arc},

};

pub use log;

pub use serde_json;

mod endpoints;

mod error;

mod node;

mod transport;

pub use endpoints::*;

pub use error::*;

use node::*;

use transport::*;

/// Substrate DEBUG log level.

pub const SUBSTRATE_DEBUG: VerbosityLevel = 9;

/// Substrate INFO log level.

pub const SUBSTRATE_INFO: VerbosityLevel = 0;

/// Consensus TRACE log level.

pub const CONSENSUS_TRACE: VerbosityLevel = 9;

/// Consensus DEBUG log level.

pub const CONSENSUS_DEBUG: VerbosityLevel = 5;

/// Consensus WARN log level.

pub const CONSENSUS_WARN: VerbosityLevel = 4;

/// Consensus INFO log level.

pub const CONSENSUS_INFO: VerbosityLevel = 1;

/// Telemetry message verbosity.

pub type VerbosityLevel = u8;

pub(crate) type Id = u64;

pub(crate) type TelemetryPayload = serde_json::Map<String, serde_json::Value>;

pub(crate) type TelemetryMessage = (Id, VerbosityLevel, TelemetryPayload);

/// Message sent when the connection (re-)establishes.

#[derive(Debug, Serialize)]

pub struct ConnectionMessage {

	/// Node's name.

	pub name: String,

	/// Node's implementation.

	pub implementation: String,

	/// Node's version.

	pub version: String,

	/// Node's configuration.

	pub config: String,

	/// Node's chain.

	pub chain: String,

	/// Node's genesis hash.

	pub genesis_hash: String,

	/// Node is an authority.

	pub authority: bool,

	/// Node's startup time.

	pub startup_time: String,

	/// Node's network ID.

	pub network_id: String,

	/// Node's OS.

	pub target_os: String,

	/// Node's ISA.

	pub target_arch: String,

	/// Node's target platform ABI or libc.

	pub target_env: String,

	/// Node's software and hardware information.

	pub sysinfo: Option<SysInfo>,

}

/// Hardware and software information for the node.

///

/// Gathering most of this information is highly OS-specific,

/// so most of the fields here are optional.

#[derive(Debug, Serialize)]

pub struct SysInfo {

	/// The exact CPU model.

	pub cpu: Option<String>,

	/// The total amount of memory, in bytes.

	pub memory: Option<u64>,

	/// The number of physical CPU cores.

	pub core_count: Option<u32>,

	/// The Linux kernel version.

	pub linux_kernel: Option<String>,

	/// The exact Linux distribution used.

	pub linux_distro: Option<String>,

	/// Whether the node's running under a virtual machine.

	pub is_virtual_machine: Option<bool>,

}

/// Telemetry worker.

///

/// It should run as a background task using the [`TelemetryWorker::run`] method. This method

/// will consume the object and any further attempts of initializing a new telemetry through its

/// handle will fail (without being fatal).

#[derive(Debug)]

pub struct TelemetryWorker {

	message_receiver: mpsc::Receiver<TelemetryMessage>,

	message_sender: mpsc::Sender<TelemetryMessage>,

	register_receiver: TracingUnboundedReceiver<Register>,

	register_sender: TracingUnboundedSender<Register>,

	id_counter: Arc<atomic::AtomicU64>,

}

impl TelemetryWorker {

	/// Instantiate a new [`TelemetryWorker`] which can run in background.

	///

	/// Only one is needed per process.

		// Let's try to initialize a transport to get an early return.

		// Later transport will be initialized multiple times in

		// `::process_register`, so it's a convenient way to get an

		// error as early as possible.

	/// Get a new [`TelemetryWorkerHandle`].

	///

	/// This is used when you want to register with the [`TelemetryWorker`].

	/// Run the telemetry worker.

	///

	/// This should be run in a background task.

		loop {

			}

		}

	}

					},

					Ok(_) => {

					},

							target: "telemetry",

							err,

						);

					},

				};

						target: "telemetry",

						addr,

					);

										target: "telemetry",

										err,

									);

								},

							};

						},

					};

						} else {

						}

			},

					// If the Node has been initialized, we directly push the connection_notifier.

					// Otherwise we push it to a queue that will be consumed when the connection

					// initializes, thus ensuring that the connection notifier will be sent to the

					// Node when it becomes available.

				}

			},

		}

	// dispatch messages to the telemetry nodes

		} else {

			// This is a normal error because the telemetry ID exists before the telemetry is

			// initialized.

				target: "telemetry",

			);

		};

			} else {

					target: "telemetry",

				);

			}

		}

}

/// Handle to the [`TelemetryWorker`] thats allows initializing the telemetry for a Substrate node.

#[derive(Debug, Clone)]

pub struct TelemetryWorkerHandle {

	message_sender: mpsc::Sender<TelemetryMessage>,

	register_sender: TracingUnboundedSender<Register>,

	id_counter: Arc<atomic::AtomicU64>,

}

impl TelemetryWorkerHandle {

	/// Instantiate a new [`Telemetry`] object.

}

/// A telemetry instance that can be used to send telemetry messages.

#[derive(Debug)]

pub struct Telemetry {

	message_sender: mpsc::Sender<TelemetryMessage>,

	register_sender: TracingUnboundedSender<Register>,

	id: Id,

	connection_notifier: TelemetryConnectionNotifier,

	endpoints: Option<TelemetryEndpoints>,

}

impl Telemetry {

	/// Initialize the telemetry with the endpoints provided in argument for the current substrate

	/// node.

	///

	/// This method must be called during the substrate node initialization.

	///

	/// The `endpoints` argument is a collection of telemetry WebSocket servers with a corresponding

	/// verbosity level.

	///

	/// The `connection_message` argument is a JSON object that is sent every time the connection

	/// (re-)establishes.

	/// Make a new clonable handle to this [`Telemetry`]. This is used for reporting telemetries.

}

/// Handle to a [`Telemetry`].

///

/// Used to report telemetry messages.

#[derive(Debug, Clone)]

pub struct TelemetryHandle {

	message_sender: Arc<Mutex<mpsc::Sender<TelemetryMessage>>>,

	id: Id,

	connection_notifier: TelemetryConnectionNotifier,

}

impl TelemetryHandle {

	/// Send telemetry messages.

				target: "telemetry",

			),

				target: "telemetry",

			),

		}

	/// Get event stream for telemetry connection established events.

	///

	/// This function will return an error if the telemetry has already been started by

	/// [`Telemetry::start_telemetry`].

}

/// Used to create a stream of events with only one event: when a telemetry connection

/// (re-)establishes.

#[derive(Clone, Debug)]

pub struct TelemetryConnectionNotifier {

	register_sender: TracingUnboundedSender<Register>,

	addresses: Vec<Multiaddr>,

}

impl TelemetryConnectionNotifier {

				target: "telemetry",

				err,

			);

}

#[derive(Debug)]

enum Register {

	Telemetry { id: Id, endpoints: TelemetryEndpoints, connection_message: ConnectionMessage },

	Notifier { addresses: Vec<Multiaddr>, connection_notifier: ConnectionNotifierSender },

}

/// Report a telemetry.

///

/// Translates to `tracing::info`, but contains an additional verbosity parameter which the log

/// record is tagged with. Additionally the verbosity parameter is added to the record as a

/// key-value pair.

///

/// # Example

///

/// ```no_run

/// # use sc_telemetry::*;

/// # let authority_id = 42_u64;

/// # let set_id = (43_u64, 44_u64);

/// # let authorities = vec![45_u64];

/// # let telemetry: Option<TelemetryHandle> = None;

/// telemetry!(

///     telemetry;      // an `Option<TelemetryHandle>`

///     CONSENSUS_INFO;

///     "afg.authority_set";

///     "authority_id" => authority_id.to_string(),

///     "authority_set_id" => ?set_id,

///     "authorities" => authorities,

/// );

/// ```

#[macro_export(local_inner_macros)]

macro_rules! telemetry {

	( $telemetry:expr; $verbosity:expr; $msg:expr; $( $t:tt )* ) => {{

		if let Some(telemetry) = $telemetry.as_ref() {

			let verbosity: $crate::VerbosityLevel = $verbosity;

			match format_fields_to_json!($($t)*) {

				Err(err) => {

					$crate::log::debug!(

						target: "telemetry",

						"Could not serialize value for telemetry: {}",

						err,

					);

				},

				Ok(mut json) => {

					json.insert("msg".into(), $msg.into());

					telemetry.send_telemetry(verbosity, json);

				},

			}

		}

	}};

}

#[macro_export(local_inner_macros)]

#[doc(hidden)]

macro_rules! format_fields_to_json {

	( $k:literal => $v:expr $(,)? $(, $($t:tt)+ )? ) => {{

		$crate::serde_json::to_value(&$v)

			$(

			)*

	}};

	( $k:literal => ? $v:expr $(,)? $(, $($t:tt)+ )? ) => {{

		let mut map = $crate::serde_json::Map::new();

		map.insert($k.into(), std::format!("{:?}", &$v).into());

		$crate::serde_json::Result::Ok(map)

		$(

		)*

	}};

}