diff options
Diffstat (limited to 'src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry')
101 files changed, 10563 insertions, 0 deletions
diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/aggregator.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/aggregator.h new file mode 100644 index 000000000..f6821d731 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/aggregator.h @@ -0,0 +1,156 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <mutex> +# include <vector> +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/common/timestamp.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +enum class AggregatorKind +{ + Counter = 0, + MinMaxSumCount = 1, + Gauge = 2, + Sketch = 3, + Histogram = 4, + Exact = 5, +}; + +/* + * Performs calculations necessary to combine updates from instruments into an + * insightful value. + * Also stores current instrument values and checkpoints collected at intervals + * governing the entire pipeline. + */ +template <typename T> +class Aggregator +{ +public: + Aggregator() = default; + + virtual ~Aggregator() = default; + + /** + * Receives a captured value from the instrument and applies it to the current aggregator value. + * + * @param val, the raw value used in aggregation + * @return none + */ + virtual void update(T val) = 0; + + /** + * Checkpoints the current value. This function will overwrite the current checkpoint with the + * current value. + * + * @param none + * @return none + */ + virtual void checkpoint() = 0; + + /** + * Merges the values of two aggregators in a semantically accurate manner. + * Merging will occur differently for different aggregators depending on the + * way values are tracked. + * + * @param other, the aggregator with merge with + * @return none + */ + void merge(Aggregator *other); + + /** + * Returns the checkpointed value + * + * @param none + * @return the value of the checkpoint + */ + virtual std::vector<T> get_checkpoint() = 0; + + /** + * Returns the current value + * + * @param none + * @return the present aggregator value + */ + virtual std::vector<T> get_values() = 0; + + /** + * Returns the instrument kind which this aggregator is associated with + * + * @param none + * @return the InstrumentKind of the aggregator's owner + */ + virtual opentelemetry::metrics::InstrumentKind get_instrument_kind() final { return kind_; } + + /** + * Returns the type of this aggregator + * + * @param none + * @return the AggregatorKind of this instrument + */ + virtual AggregatorKind get_aggregator_kind() final { return agg_kind_; } + + /** + * Getter function for updated_ protected var + * + * @return A bool indicating wether or not this aggregator has been updated + * in the most recent collection interval. + */ + virtual bool is_updated() final { return updated_; } + + // virtual function to be overridden for the Histogram Aggregator + virtual std::vector<double> get_boundaries() { return std::vector<double>(); } + + // virtual function to be overridden for the Histogram Aggregator + virtual std::vector<int> get_counts() { return std::vector<int>(); } + + // virtual function to be overridden for Exact and Sketch Aggregators + virtual bool get_quant_estimation() { return false; } + + // virtual function to be overridden for Exact and Sketch Aggregators + virtual T get_quantiles(double q) { return values_[0]; } + + // virtual function to be overridden for Sketch Aggregator + virtual double get_error_bound() { return 0; } + + // virtual function to be overridden for Sketch Aggregator + virtual size_t get_max_buckets() { return 0; } + + // virtual function to be overridden for Gauge Aggregator + virtual opentelemetry::common::SystemTimestamp get_checkpoint_timestamp() + { + return opentelemetry::common::SystemTimestamp(); + } + + // Custom copy constructor to handle the mutex + Aggregator(const Aggregator &cp) + { + values_ = cp.values_; + checkpoint_ = cp.checkpoint_; + kind_ = cp.kind_; + agg_kind_ = cp.agg_kind_; + // use default initialized mutex as they cannot be copied + } + +protected: + std::vector<T> values_; + std::vector<T> checkpoint_; + opentelemetry::metrics::InstrumentKind kind_; + std::mutex mu_; + AggregatorKind agg_kind_; + bool updated_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h new file mode 100644 index 000000000..b9842e8e0 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h @@ -0,0 +1,108 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <mutex> +# include <vector> +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/sdk/_metrics/aggregator/aggregator.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +template <class T> +class CounterAggregator final : public Aggregator<T> +{ + +public: + CounterAggregator(opentelemetry::metrics::InstrumentKind kind) + { + this->kind_ = kind; + this->values_ = std::vector<T>(1, 0); + this->checkpoint_ = std::vector<T>(1, 0); + this->agg_kind_ = AggregatorKind::Counter; + } + + /** + * Receives a captured value from the instrument and applies it to the current aggregator value. + * + * @param val, the raw value used in aggregation + * @return none + */ + void update(T val) override + { + this->mu_.lock(); + this->updated_ = true; + this->values_[0] += val; // atomic operation + this->mu_.unlock(); + } + + /** + * Checkpoints the current value. This function will overwrite the current checkpoint with the + * current value. + * + * @param none + * @return none + */ + void checkpoint() override + { + this->mu_.lock(); + this->updated_ = false; + this->checkpoint_ = this->values_; + this->values_[0] = 0; + this->mu_.unlock(); + } + + /** + * Merges the values of two aggregators in a semantically accurate manner. + * In this case, merging only requires the the current values of the two aggregators be summed. + * + * @param other, the aggregator with merge with + * @return none + */ + void merge(CounterAggregator other) + { + if (this->agg_kind_ == other.agg_kind_) + { + this->mu_.lock(); + this->values_[0] += other.values_[0]; + this->checkpoint_[0] += other.checkpoint_[0]; + this->mu_.unlock(); + } + else + { +# if __EXCEPTIONS + throw std::invalid_argument("Aggregators of different types cannot be merged."); +# else + std::terminate(); +# endif + } + } + + /** + * Returns the checkpointed value + * + * @param none + * @return the value of the checkpoint + */ + virtual std::vector<T> get_checkpoint() override { return this->checkpoint_; } + + /** + * Returns the current values + * + * @param none + * @return the present aggregator values + */ + virtual std::vector<T> get_values() override { return this->values_; } +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/exact_aggregator.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/exact_aggregator.h new file mode 100644 index 000000000..44ea717a0 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/exact_aggregator.h @@ -0,0 +1,169 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/sdk/_metrics/aggregator/aggregator.h" +# include "opentelemetry/version.h" + +# include <cmath> +# include <memory> +# include <mutex> +# include <vector> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +/** + * This aggregator has two modes. In-order and quantile estimation. + * + * The first mode simply stores all values sent to the Update() + * function in a vector and maintains the order they were sent in. + * + * The second mode also stores all values sent to the Update() + * function in a vector but sorts this vector when Checkpoint() + * is called. This mode also includes a function, Quantile(), + * that estimates the quantiles of the recorded data. + * + * @tparam T the type of values stored in this aggregator. + */ +template <class T> +class ExactAggregator : public Aggregator<T> +{ +public: + ExactAggregator(opentelemetry::metrics::InstrumentKind kind, bool quant_estimation = false) + { + static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type"); + this->kind_ = kind; + this->checkpoint_ = this->values_; + this->agg_kind_ = AggregatorKind::Exact; + quant_estimation_ = quant_estimation; + } + + ~ExactAggregator() = default; + + ExactAggregator(const ExactAggregator &cp) + { + this->values_ = cp.values_; + this->checkpoint_ = cp.checkpoint_; + this->kind_ = cp.kind_; + this->agg_kind_ = cp.agg_kind_; + quant_estimation_ = cp.quant_estimation_; + // use default initialized mutex as they cannot be copied + } + + /** + * Receives a captured value from the instrument and adds it to the values_ vector. + * + * @param val, the raw value used in aggregation + */ + void update(T val) override + { + this->mu_.lock(); + this->updated_ = true; + this->values_.push_back(val); + this->mu_.unlock(); + } + + /** + * Checkpoints the current values. This function will overwrite the current checkpoint with the + * current value. Sorts the values_ vector if quant_estimation_ == true + * + */ + void checkpoint() override + { + this->mu_.lock(); + this->updated_ = false; + if (quant_estimation_) + { + std::sort(this->values_.begin(), this->values_.end()); + } + this->checkpoint_ = this->values_; + this->values_.clear(); + this->mu_.unlock(); + } + + /** + * Merges two exact aggregators' values_ vectors together. + * + * @param other the aggregator to merge with this aggregator + */ + void merge(const ExactAggregator &other) + { + if (this->kind_ == other.kind_) + { + this->mu_.lock(); + // First merge values + this->values_.insert(this->values_.end(), other.values_.begin(), other.values_.end()); + // Now merge checkpoints + this->checkpoint_.insert(this->checkpoint_.end(), other.checkpoint_.begin(), + other.checkpoint_.end()); + this->mu_.unlock(); + } + else + { + // Log error + return; + } + } + + /** + * Performs quantile estimation on the checkpoint vector in this aggregator. + * This function only works if quant_estimation_ == true. + * @param q the quantile to estimate. 0 <= q <= 1 + * @return the nearest value in the vector to the exact quantile. + */ + T get_quantiles(double q) override + { + if (!quant_estimation_) + { +// Log error +# if __EXCEPTIONS + throw std::domain_error("Exact aggregator is not in quantile estimation mode!"); +# else + std::terminate(); +# endif + } + if (this->checkpoint_.size() == 0 || q < 0 || q > 1) + { +// Log error +# if __EXCEPTIONS + throw std::invalid_argument("Arg 'q' must be between 0 and 1, inclusive"); +# else + std::terminate(); +# endif + } + else if (q == 0 || this->checkpoint_.size() == 1) + { + return this->checkpoint_[0]; + } + else if (q == 1) + { + return this->checkpoint_[this->checkpoint_.size() - 1]; + } + else + { + float position = float(float(this->checkpoint_.size() - 1) * q); + int ceiling = int(ceil(position)); + return this->checkpoint_[ceiling]; + } + } + + //////////////////////////ACCESSOR FUNCTIONS////////////////////////// + std::vector<T> get_checkpoint() override { return this->checkpoint_; } + + std::vector<T> get_values() override { return this->values_; } + + bool get_quant_estimation() override { return quant_estimation_; } + +private: + bool quant_estimation_; // Used to switch between in-order and quantile estimation modes +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/gauge_aggregator.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/gauge_aggregator.h new file mode 100644 index 000000000..96119386d --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/gauge_aggregator.h @@ -0,0 +1,146 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/common/timestamp.h" +# include "opentelemetry/sdk/_metrics/aggregator/aggregator.h" +# include "opentelemetry/version.h" + +# include <memory> +# include <mutex> +# include <vector> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +/** + * This aggregator stores and maintains a vector of + * type T where the contents of the vector simply + * include the last value recorded to the aggregator. + * The aggregator also maintains a timestamp of when + * the last value was recorded. + * + * @tparam T the type of values stored in this aggregator. + */ +template <class T> +class GaugeAggregator : public Aggregator<T> +{ +public: + explicit GaugeAggregator(opentelemetry::metrics::InstrumentKind kind) + { + static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type"); + this->kind_ = kind; + this->values_ = std::vector<T>(1, 0); + this->checkpoint_ = this->values_; + this->agg_kind_ = AggregatorKind::Gauge; + current_timestamp_ = opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now()); + } + + ~GaugeAggregator() = default; + + GaugeAggregator(const GaugeAggregator &cp) + { + this->values_ = cp.values_; + this->checkpoint_ = cp.checkpoint_; + this->kind_ = cp.kind_; + this->agg_kind_ = cp.agg_kind_; + current_timestamp_ = cp.current_timestamp_; + // use default initialized mutex as they cannot be copied + } + + /** + * Receives a captured value from the instrument and applies it to the current aggregator value. + * + * @param val, the raw value used in aggregation + */ + void update(T val) override + { + this->mu_.lock(); + this->updated_ = true; + this->values_[0] = val; + current_timestamp_ = opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now()); + this->mu_.unlock(); + } + + /** + * Checkpoints the current value. This function will overwrite the current checkpoint with the + * current value. + * + * @return none + */ + + void checkpoint() override + { + this->mu_.lock(); + + this->updated_ = false; + this->checkpoint_ = this->values_; + + // Reset the values to default + this->values_[0] = 0; + checkpoint_timestamp_ = current_timestamp_; + current_timestamp_ = opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now()); + + this->mu_.unlock(); + } + + /** + * Merges two Gauge aggregators together + * + * @param other the aggregator to merge with this aggregator + */ + void merge(GaugeAggregator<T> other) + { + if (this->kind_ == other.kind_) + { + this->mu_.lock(); + // First merge values + this->values_[0] = other.values_[0]; + // Now merge checkpoints + this->checkpoint_[0] = other.checkpoint_[0]; + current_timestamp_ = opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now()); + this->mu_.unlock(); + } + else + { + // Log error + return; + } + } + + /** + * @return the value of the latest checkpoint + */ + std::vector<T> get_checkpoint() override { return this->checkpoint_; } + + /** + * @return the latest checkpointed timestamp + */ + opentelemetry::common::SystemTimestamp get_checkpoint_timestamp() override + { + return checkpoint_timestamp_; + } + + /** + * @return the values_ vector stored in this aggregator + */ + std::vector<T> get_values() override { return this->values_; } + + /** + * @return the timestamp of when the last value recorded + */ + opentelemetry::common::SystemTimestamp get_timestamp() { return current_timestamp_; } + +private: + opentelemetry::common::SystemTimestamp current_timestamp_; + opentelemetry::common::SystemTimestamp checkpoint_timestamp_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/histogram_aggregator.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/histogram_aggregator.h new file mode 100644 index 000000000..13e1e1244 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/histogram_aggregator.h @@ -0,0 +1,207 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <algorithm> +# include <mutex> +# include <stdexcept> +# include <vector> +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/sdk/_metrics/aggregator/aggregator.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +template <class T> +class HistogramAggregator final : public Aggregator<T> +{ + +public: + /** + * Constructor for the histogram aggregator. A sorted vector of boundaries is expected and + * boundaries are doubles regardless of the aggregator's templated data type. + * + * Sum is stored in values_[0] + * Count is stored in position_[1] + */ + HistogramAggregator(opentelemetry::metrics::InstrumentKind kind, std::vector<double> boundaries) + { + if (!std::is_sorted(boundaries.begin(), boundaries.end())) + { +# if __EXCEPTIONS + throw std::invalid_argument("Histogram boundaries must be monotonic."); +# else + std::terminate(); +# endif + } + this->kind_ = kind; + this->agg_kind_ = AggregatorKind::Histogram; + boundaries_ = boundaries; + this->values_ = std::vector<T>(2, 0); + this->checkpoint_ = std::vector<T>(2, 0); + bucketCounts_ = std::vector<int>(boundaries_.size() + 1, 0); + bucketCounts_ckpt_ = std::vector<int>(boundaries_.size() + 1, 0); + } + + /** + * Receives a captured value from the instrument and inserts it into the current histogram counts. + * + * Depending on the use case, a linear search or binary search based implementation may be + * preferred. In uniformly distributed datasets, linear search outperforms binary search until 512 + * buckets. However, if the distribution is strongly skewed right (for example server latency + * where most values may be <10ms but the range is from 0 - 1000 ms), a linear search could be + * superior even with more than 500 buckets as almost all values inserted would be at the + * beginning of the boundaries array and thus found more quickly through linear search. + * + * @param val, the raw value used in aggregation + * @return none + */ + void update(T val) override + { + this->mu_.lock(); + this->updated_ = true; + size_t bucketID = boundaries_.size(); + for (size_t i = 0; i < boundaries_.size(); i++) + { + if (val < boundaries_[i]) // concurrent read is thread-safe + { + bucketID = i; + break; + } + } + + // Alternate implementation with binary search + // auto pos = std::lower_bound (boundaries_.begin(), boundaries_.end(), val); + // bucketCounts_[pos-boundaries_.begin()] += 1; + + this->values_[0] += val; + this->values_[1] += 1; + bucketCounts_[bucketID] += 1; + this->mu_.unlock(); + } + + /** + * Checkpoints the current value. This function will overwrite the current checkpoint with the + * current value. + * + * @param none + * @return none + */ + void checkpoint() override + { + this->mu_.lock(); + this->updated_ = false; + this->checkpoint_ = this->values_; + this->values_[0] = 0; + this->values_[1] = 0; + bucketCounts_ckpt_ = bucketCounts_; + std::fill(bucketCounts_.begin(), bucketCounts_.end(), 0); + this->mu_.unlock(); + } + + /** + * Merges the values of two aggregators in a semantically accurate manner. + * A histogram aggregator can only be merged with another histogram aggregator that has the same + * boudnaries. A histogram merge first adds the sum and count values then iterates over the adds + * the bucket counts element by element. + * + * @param other, the aggregator with merge with + * @return none + */ + void merge(HistogramAggregator other) + { + this->mu_.lock(); + + // Ensure that incorrect types are not merged + if (this->agg_kind_ != other.agg_kind_) + { +# if __EXCEPTIONS + throw std::invalid_argument("Aggregators of different types cannot be merged."); +# else + std::terminate(); +# endif + // Reject histogram merges with differing boundary vectors + } + else if (other.boundaries_ != this->boundaries_) + { +# if __EXCEPTIONS + throw std::invalid_argument("Histogram boundaries do not match."); +# else + std::terminate(); +# endif + } + + this->values_[0] += other.values_[0]; + this->values_[1] += other.values_[1]; + + this->checkpoint_[0] += other.checkpoint_[0]; + this->checkpoint_[1] += other.checkpoint_[1]; + + for (size_t i = 0; i < bucketCounts_.size(); i++) + { + bucketCounts_[i] += other.bucketCounts_[i]; + bucketCounts_ckpt_[i] += other.bucketCounts_ckpt_[i]; + } + this->mu_.unlock(); + } + + /** + * Returns the checkpointed value + * + * @param none + * @return the value of the checkpoint + */ + std::vector<T> get_checkpoint() override { return this->checkpoint_; } + + /** + * Returns the current values + * + * @param none + * @return the present aggregator values + */ + std::vector<T> get_values() override { return this->values_; } + + /** + * Returns the bucket boundaries specified at this aggregator's creation. + * + * @param none + * @return the aggregator boundaries + */ + virtual std::vector<double> get_boundaries() override { return boundaries_; } + + /** + * Returns the current counts for each bucket . + * + * @param none + * @return the aggregator bucket counts + */ + virtual std::vector<int> get_counts() override { return bucketCounts_ckpt_; } + + HistogramAggregator(const HistogramAggregator &cp) + { + this->values_ = cp.values_; + this->checkpoint_ = cp.checkpoint_; + this->kind_ = cp.kind_; + this->agg_kind_ = cp.agg_kind_; + boundaries_ = cp.boundaries_; + bucketCounts_ = cp.bucketCounts_; + bucketCounts_ckpt_ = cp.bucketCounts_ckpt_; + // use default initialized mutex as they cannot be copied + } + +private: + std::vector<double> boundaries_; + std::vector<int> bucketCounts_; + std::vector<int> bucketCounts_ckpt_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/min_max_sum_count_aggregator.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/min_max_sum_count_aggregator.h new file mode 100644 index 000000000..60628b567 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/min_max_sum_count_aggregator.h @@ -0,0 +1,159 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/sdk/_metrics/aggregator/aggregator.h" +# include "opentelemetry/version.h" + +# include <memory> +# include <mutex> +# include <vector> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +const int MinValueIndex = 0; +const int MaxValueIndex = 1; +const int SumValueIndex = 2; +const int CountValueIndex = 3; +/** + * This aggregator stores and maintains a vector of + * type T where the contents in the vector are made + * up of the minimum value recorded to this instrument, + * the maximum value, the sum of all values, and the + * count of all values. + * + * @tparam T the type of values stored in this aggregator. + */ +template <class T> +class MinMaxSumCountAggregator : public Aggregator<T> +{ +public: + explicit MinMaxSumCountAggregator(opentelemetry::metrics::InstrumentKind kind) + { + static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type"); + this->kind_ = kind; + this->values_ = std::vector<T>(4, 0); // {min, max, sum, count} + this->checkpoint_ = this->values_; + this->agg_kind_ = AggregatorKind::MinMaxSumCount; + } + + ~MinMaxSumCountAggregator() = default; + + MinMaxSumCountAggregator(const MinMaxSumCountAggregator &cp) + { + this->values_ = cp.values_; + this->checkpoint_ = cp.checkpoint_; + this->kind_ = cp.kind_; + this->agg_kind_ = cp.agg_kind_; + // use default initialized mutex as they cannot be copied + } + + /** + * Receives a captured value from the instrument and applies it to the current aggregator value. + * + * @param val, the raw value used in aggregation + */ + void update(T val) override + { + this->mu_.lock(); + this->updated_ = true; + + if (this->values_[CountValueIndex] == 0 || val < this->values_[MinValueIndex]) // set min + this->values_[MinValueIndex] = val; + if (this->values_[CountValueIndex] == 0 || val > this->values_[MaxValueIndex]) // set max + this->values_[MaxValueIndex] = val; + + this->values_[SumValueIndex] += val; // compute sum + this->values_[CountValueIndex]++; // increment count + + this->mu_.unlock(); + } + + /** + * Checkpoints the current value. This function will overwrite the current checkpoint with the + * current value. + * + */ + void checkpoint() override + { + this->mu_.lock(); + this->updated_ = false; + this->checkpoint_ = this->values_; + // Reset the values + this->values_[MinValueIndex] = 0; + this->values_[MaxValueIndex] = 0; + this->values_[SumValueIndex] = 0; + this->values_[CountValueIndex] = 0; + this->mu_.unlock(); + } + + /** + * Merges two MinMaxSumCount aggregators together + * + * @param other the aggregator to merge with this aggregator + */ + void merge(const MinMaxSumCountAggregator &other) + { + if (this->kind_ == other.kind_) + { + this->mu_.lock(); + // First merge values + // set min + if (this->values_[CountValueIndex] == 0 || + other.values_[MinValueIndex] < this->values_[MinValueIndex]) + this->values_[MinValueIndex] = other.values_[MinValueIndex]; + // set max + if (this->values_[CountValueIndex] == 0 || + other.values_[MaxValueIndex] > this->values_[MaxValueIndex]) + this->values_[MaxValueIndex] = other.values_[MaxValueIndex]; + // set sum + this->values_[SumValueIndex] += other.values_[SumValueIndex]; + // set count + this->values_[CountValueIndex] += other.values_[CountValueIndex]; + + // Now merge checkpoints + if (this->checkpoint_[CountValueIndex] == 0 || + other.checkpoint_[MinValueIndex] < this->checkpoint_[MinValueIndex]) + this->checkpoint_[MinValueIndex] = other.checkpoint_[MinValueIndex]; + // set max + if (this->checkpoint_[CountValueIndex] == 0 || + other.checkpoint_[MaxValueIndex] > this->checkpoint_[MaxValueIndex]) + this->checkpoint_[MaxValueIndex] = other.checkpoint_[MaxValueIndex]; + // set sum + this->checkpoint_[SumValueIndex] += other.checkpoint_[SumValueIndex]; + // set count + this->checkpoint_[CountValueIndex] += other.checkpoint_[CountValueIndex]; + + this->mu_.unlock(); + } + else + { + // Log error + return; + } + } + + /** + * Returns the checkpointed value + * + * @return the value of the checkpoint + */ + std::vector<T> get_checkpoint() override { return this->checkpoint_; } + + /** + * Returns the values currently held by the aggregator + * + * @return the values held by the aggregator + */ + std::vector<T> get_values() override { return this->values_; } +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/sketch_aggregator.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/sketch_aggregator.h new file mode 100644 index 000000000..3942c9550 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/aggregator/sketch_aggregator.h @@ -0,0 +1,282 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <algorithm> +# include <cmath> +# include <limits> +# include <map> +# include <mutex> +# include <stdexcept> +# include <vector> +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/sdk/_metrics/aggregator/aggregator.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +/** Sketch Aggregators implement the DDSketch data type. Note that data is compressed + * by the DDSketch algorithm and users should be informed about its behavior before + * selecting it as the aggregation type. NOTE: The current implementation can only support + * non-negative values. + * + * Detailed information about the algorithm can be found in the following paper + * published by Datadog: http://www.vldb.org/pvldb/vol12/p2195-masson.pdf + */ + +template <class T> +class SketchAggregator final : public Aggregator<T> +{ + +public: + /** + * Given the distribution of data this aggregator is designed for and its usage, the raw updates + *are stored in a map rather than a vector. + * + *@param kind, the instrument kind creating this aggregator + *@param error_bound, what is referred to as "alpha" in the DDSketch algorithm + *@param max_buckets, the maximum number of indices in the raw value map + */ + SketchAggregator(opentelemetry::metrics::InstrumentKind kind, + double error_bound, + size_t max_buckets = 2048) + { + + this->kind_ = kind; + this->agg_kind_ = AggregatorKind::Sketch; + this->values_ = std::vector<T>(2, 0); // Sum in [0], Count in [1] + this->checkpoint_ = std::vector<T>(2, 0); + max_buckets_ = max_buckets; + error_bound_ = error_bound; + gamma = (1 + error_bound) / (1 - error_bound); + } + + /** + * Update the aggregator with the new value. For a DDSketch aggregator, if the addition of this + * value creates a new bucket which is in excess of the maximum allowed size, the lowest indexes + * buckets are merged. + * + * @param val, the raw value used in aggregation + * @return none + */ + void update(T val) override + { + this->mu_.lock(); + this->updated_ = true; + int idx; + if (val == 0) + { + idx = (std::numeric_limits<int>::min()); + } + else + { + idx = static_cast<int>(ceil(log(val) / log(gamma))); + } + if (raw_.find(idx) != raw_.end()) + { + raw_[idx] += 1; + } + else + { + raw_[idx] = 1; + } + this->values_[1] += 1; + this->values_[0] += val; + if (raw_.size() > max_buckets_) + { + int minidx = raw_.begin()->first, minidxval = raw_.begin()->second; + raw_.erase(minidx); + raw_[raw_.begin()->first] += minidxval; + } + this->mu_.unlock(); + } + + /** + * Calculate and return the value of a user specified quantile. + * + * @param q, the quantile to calculate (for example 0.5 is equivalent to the 50th percentile) + */ + virtual T get_quantiles(double q) override + { + if (q < 0 || q > 1) + { +# if __EXCEPTIONS + throw std::invalid_argument("Quantile values must fall between 0 and 1"); +# else + std::terminate(); +# endif + } + auto iter = checkpoint_raw_.begin(); + int idx = iter->first; + int count = iter->second; + + while (count < (q * (this->checkpoint_[1] - 1)) && iter != checkpoint_raw_.end()) + { + iter++; + idx = iter->first; + count += iter->second; + } + return static_cast<T>(round(2 * pow(gamma, idx) / (gamma + 1))); + } + + /** + * Checkpoints the current value. This function will overwrite the current checkpoint with the + * current value. + * + * @param none + * @return none + */ + void checkpoint() override + { + this->mu_.lock(); + this->updated_ = false; + this->checkpoint_ = this->values_; + checkpoint_raw_ = raw_; + this->values_[0] = 0; + this->values_[1] = 0; + raw_.clear(); + this->mu_.unlock(); + } + + /** + * Merges this sketch aggregator with another. The same bucket compression used when + * updating values is employed here to manage bucket size if the merging of aggregators + * results in more buckets than allowed. + * + * @param other, the aggregator with merge with + * @return none + */ + void merge(SketchAggregator other) + { + if (gamma != other.gamma) + { +# if __EXCEPTIONS + throw std::invalid_argument("Aggregators must have identical error tolerance"); +# else + std::terminate(); +# endif + } + else if (max_buckets_ != other.max_buckets_) + { +# if __EXCEPTIONS + throw std::invalid_argument("Aggregators must have the same maximum bucket allowance"); +# else + std::terminate(); +# endif + } + + this->mu_.lock(); + this->values_[0] += other.values_[0]; + this->values_[1] += other.values_[1]; + this->checkpoint_[0] += other.checkpoint_[0]; + this->checkpoint_[1] += other.checkpoint_[1]; + auto other_iter = other.raw_.begin(); + while (other_iter != other.raw_.end()) + { + raw_[other_iter->first] += other_iter->second; + if (raw_.size() > max_buckets_) + { + int minidx = raw_.begin()->first, minidxval = raw_.begin()->second; + raw_.erase(minidx); + raw_[raw_.begin()->first] += minidxval; + } + other_iter++; + } + auto other_ckpt_iter = other.checkpoint_raw_.begin(); + while (other_ckpt_iter != other.checkpoint_raw_.end()) + { + checkpoint_raw_[other_ckpt_iter->first] += other_ckpt_iter->second; + if (checkpoint_raw_.size() > max_buckets_) + { + int minidx = checkpoint_raw_.begin()->first, minidxval = checkpoint_raw_.begin()->second; + checkpoint_raw_.erase(minidx); + checkpoint_raw_[checkpoint_raw_.begin()->first] += minidxval; + } + other_ckpt_iter++; + } + this->mu_.unlock(); + } + + /** + * Returns the checkpointed value + * + * @param none + * @return the value of the checkpoint + */ + std::vector<T> get_checkpoint() override { return this->checkpoint_; } + + /** + * Returns the current values + * + * @param none + * @return the present aggregator values + */ + std::vector<T> get_values() override { return this->values_; } + + /** + * Returns the indices (or values) stored by this sketch aggregator. + * + * @param none + * @return a vector of all values the aggregator is currently tracking + */ + virtual std::vector<double> get_boundaries() override + { + std::vector<double> ret; + for (auto const &x : checkpoint_raw_) + { + ret.push_back(2 * pow(gamma, x.first) / (gamma + 1)); + } + return ret; + } + + /** + * Returns the error bound + * + * @param none + * @return the error bound specified during construction + */ + virtual double get_error_bound() override { return error_bound_; } + + /** + * Returns the maximum allowed buckets + * + * @param none + * @return the maximum allowed buckets + */ + virtual size_t get_max_buckets() override { return max_buckets_; } + + /** + * Returns the count of each value tracked by this sketch aggregator. These are returned + * in the same order as the indices returned by the get_boundaries function. + * + * @param none + * @return a vector of all counts for values tracked by the aggregator + */ + virtual std::vector<int> get_counts() override + { + std::vector<int> ret; + for (auto const &x : checkpoint_raw_) + { + ret.push_back(x.second); + } + return ret; + } + +private: + double gamma; + double error_bound_; + size_t max_buckets_; + std::map<int, int> raw_; + std::map<int, int> checkpoint_raw_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/async_instruments.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/async_instruments.h new file mode 100644 index 000000000..5213a4e2e --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/async_instruments.h @@ -0,0 +1,286 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <map> +# include <memory> +# include <sstream> +# include <stdexcept> +# include <vector> +# include "opentelemetry/_metrics/async_instruments.h" +# include "opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h" +# include "opentelemetry/sdk/_metrics/aggregator/min_max_sum_count_aggregator.h" +# include "opentelemetry/sdk/_metrics/instrument.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4250) // inheriting methods via dominance +# endif + +template <class T> +class ValueObserver : public AsynchronousInstrument<T>, + virtual public opentelemetry::metrics::ValueObserver<T> +{ + +public: + ValueObserver() = default; + + ValueObserver(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<T>)) + : AsynchronousInstrument<T>(name, + description, + unit, + enabled, + callback, + opentelemetry::metrics::InstrumentKind::ValueObserver) + {} + + /* + * Updates the instruments aggregator with the new value. The labels should + * contain the keys and values to be associated with this value. + * + * @param value is the numerical representation of the metric being captured + * @param labels the set of labels, as key-value pairs + */ + virtual void observe(T value, const opentelemetry::common::KeyValueIterable &labels) override + { + this->mu_.lock(); + std::string labelset = KvToString(labels); + if (boundAggregators_.find(labelset) == boundAggregators_.end()) + { + auto sp1 = std::shared_ptr<Aggregator<T>>(new MinMaxSumCountAggregator<T>(this->kind_)); + boundAggregators_.insert(std::make_pair(labelset, sp1)); + sp1->update(value); + } + else + { + boundAggregators_[labelset]->update(value); + } + this->mu_.unlock(); + } + + /* + * Activate the instrument's callback function to record a measurement. This + * function will be called by the specified controller at a regular interval. + * + * @param none + * @return none + */ + virtual void run() override + { + opentelemetry::metrics::ObserverResult<T> res(this); + this->callback_(res); + } + + virtual std::vector<Record> GetRecords() override + { + this->mu_.lock(); + std::vector<Record> ret; + for (auto x : boundAggregators_) + { + x.second->checkpoint(); + ret.push_back(Record(this->GetName(), this->GetDescription(), x.first, x.second)); + } + boundAggregators_.clear(); + this->mu_.unlock(); + return ret; + } + + // Public mapping from labels (stored as strings) to their respective aggregators + std::unordered_map<std::string, std::shared_ptr<Aggregator<T>>> boundAggregators_; +}; + +template <class T> +class SumObserver : public AsynchronousInstrument<T>, + virtual public opentelemetry::metrics::SumObserver<T> +{ + +public: + SumObserver() = default; + + SumObserver(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<T>)) + : AsynchronousInstrument<T>(name, + description, + unit, + enabled, + callback, + opentelemetry::metrics::InstrumentKind::SumObserver) + {} + + /* + * Updates the instruments aggregator with the new value. The labels should + * contain the keys and values to be associated with this value. + * + * @param value is the numerical representation of the metric being captured + * @param labels the set of labels, as key-value pairs + */ + virtual void observe(T value, const opentelemetry::common::KeyValueIterable &labels) override + { + this->mu_.lock(); + std::string labelset = KvToString(labels); + if (boundAggregators_.find(labelset) == boundAggregators_.end()) + { + auto sp1 = std::shared_ptr<Aggregator<T>>(new CounterAggregator<T>(this->kind_)); + boundAggregators_.insert(std::make_pair(labelset, sp1)); + if (value < 0) + { +# if __EXCEPTIONS + throw std::invalid_argument("Counter instrument updates must be non-negative."); +# else + std::terminate(); +# endif + } + else + { + sp1->update(value); + } + } + else + { + if (value < 0) + { +# if __EXCEPTIONS + throw std::invalid_argument("Counter instrument updates must be non-negative."); +# else + std::terminate(); +# endif + } + else + { + boundAggregators_[labelset]->update(value); + } + } + this->mu_.unlock(); + } + + /* + * Activate the intsrument's callback function to record a measurement. This + * function will be called by the specified controller at a regular interval. + * + * @param none + * @return none + */ + virtual void run() override + { + opentelemetry::metrics::ObserverResult<T> res(this); + this->callback_(res); + } + + virtual std::vector<Record> GetRecords() override + { + this->mu_.lock(); + std::vector<Record> ret; + for (auto x : boundAggregators_) + { + x.second->checkpoint(); + ret.push_back(Record(this->GetName(), this->GetDescription(), x.first, x.second)); + } + boundAggregators_.clear(); + this->mu_.unlock(); + return ret; + } + + // Public mapping from labels (stored as strings) to their respective aggregators + std::unordered_map<std::string, std::shared_ptr<Aggregator<T>>> boundAggregators_; +}; + +template <class T> +class UpDownSumObserver : public AsynchronousInstrument<T>, + virtual public opentelemetry::metrics::UpDownSumObserver<T> +{ + +public: + UpDownSumObserver() = default; + + UpDownSumObserver(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<T>)) + : AsynchronousInstrument<T>(name, + description, + unit, + enabled, + callback, + opentelemetry::metrics::InstrumentKind::UpDownSumObserver) + {} + + /* + * Updates the instruments aggregator with the new value. The labels should + * contain the keys and values to be associated with this value. + * + * @param value is the numerical representation of the metric being captured + * @param labels the set of labels, as key-value pairs + */ + virtual void observe(T value, const opentelemetry::common::KeyValueIterable &labels) override + { + this->mu_.lock(); + std::string labelset = KvToString(labels); + if (boundAggregators_.find(labelset) == boundAggregators_.end()) + { + auto sp1 = std::shared_ptr<Aggregator<T>>(new CounterAggregator<T>(this->kind_)); + boundAggregators_.insert(std::make_pair(labelset, sp1)); + sp1->update(value); + } + else + { + boundAggregators_[labelset]->update(value); + } + this->mu_.unlock(); + } + + /* + * Activate the intsrument's callback function to record a measurement. This + * function will be called by the specified controller at a regular interval. + * + * @param none + * @return none + */ + virtual void run() override + { + opentelemetry::metrics::ObserverResult<T> res(this); + this->callback_(res); + } + + virtual std::vector<Record> GetRecords() override + { + this->mu_.lock(); + std::vector<Record> ret; + for (auto x : boundAggregators_) + { + x.second->checkpoint(); + ret.push_back(Record(this->GetName(), this->GetDescription(), x.first, x.second)); + } + boundAggregators_.clear(); + this->mu_.unlock(); + return ret; + } + + // Public mapping from labels (stored as strings) to their respective aggregators + std::unordered_map<std::string, std::shared_ptr<Aggregator<T>>> boundAggregators_; +}; + +# if defined(_MSC_VER) +# pragma warning(pop) +# endif + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/controller.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/controller.h new file mode 100644 index 000000000..66a57a2ef --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/controller.h @@ -0,0 +1,154 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <atomic> +# include <iostream> +# include <sstream> +# include <thread> +# include <vector> + +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/common/macros.h" +# include "opentelemetry/nostd/unique_ptr.h" +# include "opentelemetry/sdk/_metrics/exporter.h" +# include "opentelemetry/sdk/_metrics/meter.h" +# include "opentelemetry/sdk/_metrics/processor.h" +# include "opentelemetry/sdk/_metrics/record.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class PushController +{ + +public: + PushController(nostd::shared_ptr<opentelemetry::metrics::Meter> meter, + nostd::unique_ptr<MetricsExporter> exporter, + nostd::shared_ptr<MetricsProcessor> processor, + double period, + int timeout = 30) + { + meter_ = meter; + exporter_ = std::move(exporter); + processor_ = processor; + timeout_ = (unsigned int)(timeout * 1000000); // convert seconds to microseconds + period_ = (unsigned int)(period * 1000000); + } + + /* + * Used to check if the metrics pipeline is currently active + * + * @param none + * @return true when active, false when on standby. This is a best guess estimate + * and the boolean from start() should be used to determine wheher the pipeline + * was initiated successfully. + */ + bool isActive() { return active_.load(); } + + /* + * Begins the data processing and export pipeline. The function first ensures that the pipeline + * is not already running. If not, it begins and detaches a new thread for the Controller's run + * function which periodically polls the instruments for their data. + * + * @param none + * @return a boolean which is true when the pipeline is successfully started and false when + * already active + */ + bool start() + { + if (!active_.exchange(true)) + { + runner_ = std::thread(&PushController::run, this); + return true; + } + return false; + } + + /* + * Ends the processing and export pipeline then exports metrics one last time + * before returning. + * + * @param none + * @return none + */ + void stop() + { + if (active_.exchange(false)) + { + if (runner_.joinable()) + { + runner_.join(); + } + tick(); // flush metrics sitting in the processor + } + } + +private: + /* + * Run the tick function at a regular interval. This function + * should be run in its own thread. + * + * Used to wait between collection intervals. + */ + void run() + { + if (!running_.exchange(true)) + { + while (active_.load()) + { + tick(); + std::this_thread::sleep_for(std::chrono::microseconds(period_)); + } + running_.exchange(false); + } + } + + /* + * Tick + * + * Called at regular intervals, this function collects all values from the + * member variable meter_, then sends them to the processor_ for + * processing. After the records have been processed they are sent to the + * exporter_ to be exported. + * + */ + void tick() + { + this->mu_.lock(); +# ifdef OPENTELEMETRY_RTTI_ENABLED + std::vector<Record> collected = dynamic_cast<Meter *>(meter_.get())->Collect(); +# else + std::vector<Record> collected = static_cast<Meter *>(meter_.get())->Collect(); +# endif + for (const auto &rec : collected) + { + processor_->process(rec); + } + collected = processor_->CheckpointSelf(); + processor_->FinishedCollection(); + exporter_->Export(collected); + this->mu_.unlock(); + } + + nostd::shared_ptr<opentelemetry::metrics::Meter> meter_; + nostd::unique_ptr<MetricsExporter> exporter_; + nostd::shared_ptr<MetricsProcessor> processor_; + std::thread runner_; + std::mutex mu_; + std::atomic<bool> active_ = ATOMIC_VAR_INIT(false); + std::atomic<bool> running_ = ATOMIC_VAR_INIT(false); + unsigned int period_; + unsigned int timeout_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/exporter.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/exporter.h new file mode 100644 index 000000000..aae416527 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/exporter.h @@ -0,0 +1,35 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <memory> +# include "opentelemetry/sdk/_metrics/record.h" +# include "opentelemetry/sdk/common/exporter_utils.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +/** + * MetricsExporter defines the interface that protocol-specific span exporters must + * implement. + */ +class MetricsExporter +{ +public: + virtual ~MetricsExporter() = default; + + /** + * Exports a vector of Records. This method must not be called + * concurrently for the same exporter instance. + * @param records a vector of unique pointers to metric records + */ + virtual sdk::common::ExportResult Export(const std::vector<Record> &records) noexcept = 0; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/instrument.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/instrument.h new file mode 100644 index 000000000..51111be5e --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/instrument.h @@ -0,0 +1,312 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <iostream> +# include <map> +# include <memory> +# include <sstream> +# include <string> +# include <unordered_map> +# include <vector> +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/sdk/_metrics/aggregator/aggregator.h" +# include "opentelemetry/sdk/_metrics/record.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4250) // inheriting methods via dominance +# endif + +class Instrument : virtual public opentelemetry::metrics::Instrument +{ + +public: + Instrument() = default; + + Instrument(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled, + opentelemetry::metrics::InstrumentKind kind) + : name_(name), description_(description), unit_(unit), enabled_(enabled), kind_(kind) + {} + + // Returns true if the instrument is enabled and collecting data + virtual bool IsEnabled() override { return enabled_; } + + // Return the instrument name + virtual nostd::string_view GetName() override { return name_; } + + // Return the instrument description + virtual nostd::string_view GetDescription() override { return description_; } + + // Return the insrument's units of measurement + virtual nostd::string_view GetUnits() override { return unit_; } + + virtual opentelemetry::metrics::InstrumentKind GetKind() override { return this->kind_; } + +protected: + std::string name_; + std::string description_; + std::string unit_; + bool enabled_; + std::mutex mu_; + opentelemetry::metrics::InstrumentKind kind_; +}; + +template <class T> +class BoundSynchronousInstrument + : public Instrument, + virtual public opentelemetry::metrics::BoundSynchronousInstrument<T> +{ + +public: + BoundSynchronousInstrument() = default; + + BoundSynchronousInstrument(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled, + opentelemetry::metrics::InstrumentKind kind, + std::shared_ptr<Aggregator<T>> agg) + : Instrument(name, description, unit, enabled, kind), agg_(agg) + { + this->inc_ref(); // increase reference count when instantiated + } + + /** + * Frees the resources associated with this Bound Instrument. + * The Metric from which this instrument was created is not impacted. + * + * @param none + * @return void + */ + virtual void unbind() override + { + this->mu_.lock(); + ref_ -= 1; + this->mu_.unlock(); + } + + /** + * Increments the reference count. This function is used when binding or instantiating. + * + * @param none + * @return void + */ + virtual void inc_ref() override + { + this->mu_.lock(); + ref_ += 1; + this->mu_.unlock(); + } + + /** + * Returns the current reference count of the instrument. This value is used to + * later in the pipeline remove stale instruments. + * + * @param none + * @return current ref count of the instrument + */ + virtual int get_ref() override + { + this->mu_.lock(); + auto ret = ref_; + this->mu_.unlock(); + return ret; + } + + /** + * Records a single synchronous metric event via a call to the aggregator. + * Since this is a bound synchronous instrument, labels are not required in + * metric capture calls. + * + * @param value is the numerical representation of the metric being captured + * @return void + */ + virtual void update(T value) override + { + this->mu_.lock(); + agg_->update(value); + this->mu_.unlock(); + } + + /** + * Returns the aggregator responsible for meaningfully combining update values. + * + * @param none + * @return the aggregator assigned to this instrument + */ + virtual std::shared_ptr<Aggregator<T>> GetAggregator() final { return agg_; } + +private: + std::shared_ptr<Aggregator<T>> agg_; + int ref_ = 0; +}; + +template <class T> +class SynchronousInstrument : public Instrument, + virtual public opentelemetry::metrics::SynchronousInstrument<T> +{ + +public: + SynchronousInstrument() = default; + + SynchronousInstrument(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled, + opentelemetry::metrics::InstrumentKind kind) + : Instrument(name, description, unit, enabled, kind) + {} + + /** + * Returns a Bound Instrument associated with the specified labels. Multiples requests + * with the same set of labels may return the same Bound Instrument instance. + * + * It is recommended that callers keep a reference to the Bound Instrument + * instead of repeatedly calling this operation. + * + * @param labels the set of labels, as key-value pairs + * @return a Bound Instrument + */ + virtual nostd::shared_ptr<opentelemetry::metrics::BoundSynchronousInstrument<T>> bind( + const opentelemetry::common::KeyValueIterable &labels) override + { + return nostd::shared_ptr<BoundSynchronousInstrument<T>>(); + } + + // This function is necessary for batch recording and should NOT be called by the user + virtual void update(T value, const opentelemetry::common::KeyValueIterable &labels) override = 0; + + /** + * Checkpoints instruments and returns a set of records which are ready for processing. + * This method should ONLY be called by the Meter Class as part of the export pipeline + * as it also prunes bound instruments with no active references. + * + * @param none + * @return vector of Records which hold the data attached to this synchronous instrument + */ + virtual std::vector<Record> GetRecords() = 0; +}; + +template <class T> +class AsynchronousInstrument : public Instrument, + virtual public opentelemetry::metrics::AsynchronousInstrument<T> +{ + +public: + AsynchronousInstrument() = default; + + AsynchronousInstrument(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<T>), + opentelemetry::metrics::InstrumentKind kind) + : Instrument(name, description, unit, enabled, kind) + { + this->callback_ = callback; + } + + /** + * Captures data through a manual call rather than the automatic collection process instituted + * in the run function. Asynchronous instruments are generally expected to obtain data from + * their callbacks rather than direct calls. This function is used by the callback to store data. + * + * @param value is the numerical representation of the metric being captured + * @param labels is the numerical representation of the metric being captured + * @return none + */ + virtual void observe(T value, const opentelemetry::common::KeyValueIterable &labels) override = 0; + + virtual std::vector<Record> GetRecords() = 0; + + /** + * Captures data by activating the callback function associated with the + * instrument and storing its return value. Callbacks for asynchronous + * instruments are defined during construction. + * + * @param none + * @return none + */ + virtual void run() override = 0; +}; + +// Helper functions for turning a common::KeyValueIterable into a string +inline void print_value(std::stringstream &ss, + opentelemetry::common::AttributeValue &value, + bool jsonTypes = false) +{ + switch (value.index()) + { + case opentelemetry::common::AttributeType::kTypeString: + + ss << nostd::get<nostd::string_view>(value); + + break; + default: +# if __EXCEPTIONS + throw std::invalid_argument("Labels must be strings"); +# else + std::terminate(); +# endif + break; + } +}; + +// Utility function which converts maps to strings for better performance +inline std::string mapToString(const std::map<std::string, std::string> &conv) +{ + std::stringstream ss; + ss << "{"; + for (auto i : conv) + { + ss << i.first << ':' << i.second << ','; + } + ss << "}"; + return ss.str(); +} + +inline std::string KvToString(const opentelemetry::common::KeyValueIterable &kv) noexcept +{ + std::stringstream ss; + ss << "{"; + size_t size = kv.size(); + if (size) + { + size_t i = 1; + kv.ForEachKeyValue( + [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept { + ss << key << ":"; + print_value(ss, value, true); + if (size != i) + { + ss << ","; + } + i++; + return true; + }); + }; + ss << "}"; + return ss.str(); +} + +# if defined(_MSC_VER) +# pragma warning(pop) +# endif + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/meter.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/meter.h new file mode 100644 index 000000000..a91a3ed2b --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/meter.h @@ -0,0 +1,392 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include "opentelemetry/_metrics/meter.h" +# include "opentelemetry/nostd/shared_ptr.h" +# include "opentelemetry/sdk/_metrics/async_instruments.h" +# include "opentelemetry/sdk/_metrics/instrument.h" +# include "opentelemetry/sdk/_metrics/record.h" +# include "opentelemetry/sdk/_metrics/sync_instruments.h" + +# include <unordered_set> +# include <vector> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class Meter : public opentelemetry::metrics::Meter +{ +public: + explicit Meter(std::string library_name, std::string library_version = "") + { + library_name_ = library_name; + library_version_ = library_version; + } + + /** + * Creates a Counter with the passed characteristics and returns a shared_ptr to that Counter. + * + * @param name the name of the new Counter. + * @param description a brief description of what the Counter is used for. + * @param unit the unit of metric values following https://unitsofmeasure.org/ucum.html. + * @param enabled a boolean value that turns on or off the metric instrument. + * @return a shared pointer to the created Counter. + * @throws invalid_argument exception if name is null or does not conform to OTel syntax. + */ + nostd::shared_ptr<opentelemetry::metrics::Counter<short>> NewShortCounter( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + nostd::shared_ptr<opentelemetry::metrics::Counter<int>> NewIntCounter( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + nostd::shared_ptr<opentelemetry::metrics::Counter<float>> NewFloatCounter( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + nostd::shared_ptr<opentelemetry::metrics::Counter<double>> NewDoubleCounter( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + /** + * Creates an UpDownCounter with the passed characteristics and returns a shared_ptr to that + * UpDownCounter. + * + * @param name the name of the new UpDownCounter. + * @param description a brief description of what the UpDownCounter is used for. + * @param unit the unit of metric values following https://unitsofmeasure.org/ucum.html. + * @param enabled a boolean value that turns on or off the metric instrument. + * @return a shared pointer to the created UpDownCounter. + * @throws invalid_argument exception if name is null or does not conform to OTel syntax. + */ + nostd::shared_ptr<opentelemetry::metrics::UpDownCounter<short>> NewShortUpDownCounter( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + nostd::shared_ptr<opentelemetry::metrics::UpDownCounter<int>> NewIntUpDownCounter( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + nostd::shared_ptr<opentelemetry::metrics::UpDownCounter<float>> NewFloatUpDownCounter( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + nostd::shared_ptr<opentelemetry::metrics::UpDownCounter<double>> NewDoubleUpDownCounter( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + /** + * Creates a ValueRecorder with the passed characteristics and returns a shared_ptr to that + * ValueRecorder. + * + * @param name the name of the new ValueRecorder. + * @param description a brief description of what the ValueRecorder is used for. + * @param unit the unit of metric values following https://unitsofmeasure.org/ucum.html. + * @param enabled a boolean value that turns on or off the metric instrument. + * @return a shared pointer to the created DoubleValueRecorder. + * @throws invalid_argument exception if name is null or does not conform to OTel syntax. + */ + nostd::shared_ptr<opentelemetry::metrics::ValueRecorder<short>> NewShortValueRecorder( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + nostd::shared_ptr<opentelemetry::metrics::ValueRecorder<int>> NewIntValueRecorder( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + nostd::shared_ptr<opentelemetry::metrics::ValueRecorder<float>> NewFloatValueRecorder( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + nostd::shared_ptr<opentelemetry::metrics::ValueRecorder<double>> NewDoubleValueRecorder( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled) override; + + /** + * Creates a SumObserver with the passed characteristics and returns a shared_ptr to that + * SumObserver. + * + * @param name the name of the new SumObserver. + * @param description a brief description of what the SumObserver is used for. + * @param unit the unit of metric values following https://unitsofmeasure.org/ucum.html. + * @param enabled a boolean value that turns on or off the metric instrument. + * @param callback the function to be observed by the instrument. + * @return a shared pointer to the created SumObserver. + * @throws invalid_argument exception if name is null or does not conform to OTel syntax. + */ + nostd::shared_ptr<opentelemetry::metrics::SumObserver<short>> NewShortSumObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<short>)) override; + + nostd::shared_ptr<opentelemetry::metrics::SumObserver<int>> NewIntSumObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<int>)) override; + + nostd::shared_ptr<opentelemetry::metrics::SumObserver<float>> NewFloatSumObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<float>)) override; + + nostd::shared_ptr<opentelemetry::metrics::SumObserver<double>> NewDoubleSumObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<double>)) override; + + /** + * Creates an UpDownSumObserver with the passed characteristics and returns a shared_ptr to + * that UpDowNSumObserver. + * + * @param name the name of the new UpDownSumObserver. + * @param description a brief description of what the UpDownSumObserver is used for. + * @param unit the unit of metric values following https://unitsofmeasure.org/ucum.html. + * @param enabled a boolean value that turns on or off the metric instrument. + * @param callback the function to be observed by the instrument. + * @return a shared pointer to the created UpDownSumObserver. + * @throws invalid_argument exception if name is null or does not conform to OTel syntax. + */ + nostd::shared_ptr<opentelemetry::metrics::UpDownSumObserver<short>> NewShortUpDownSumObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<short>)) override; + + nostd::shared_ptr<opentelemetry::metrics::UpDownSumObserver<int>> NewIntUpDownSumObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<int>)) override; + + nostd::shared_ptr<opentelemetry::metrics::UpDownSumObserver<float>> NewFloatUpDownSumObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<float>)) override; + + nostd::shared_ptr<opentelemetry::metrics::UpDownSumObserver<double>> NewDoubleUpDownSumObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<double>)) override; + + /** + * Creates a ValueObserver with the passed characteristics and returns a shared_ptr to that + * ValueObserver. + * + * @param name the name of the new ValueObserver. + * @param description a brief description of what the ValueObserver is used for. + * @param unit the unit of metric values following https://unitsofmeasure.org/ucum.html. + * @param enabled a boolean value that turns on or off the metric instrument. + * @param callback the function to be observed by the instrument. + * @return a shared pointer to the created ValueObserver. + * @throws invalid_argument exception if name is null or does not conform to OTel syntax. + */ + nostd::shared_ptr<opentelemetry::metrics::ValueObserver<short>> NewShortValueObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<short>)) override; + + nostd::shared_ptr<opentelemetry::metrics::ValueObserver<int>> NewIntValueObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<int>)) override; + + nostd::shared_ptr<opentelemetry::metrics::ValueObserver<float>> NewFloatValueObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<float>)) override; + + nostd::shared_ptr<opentelemetry::metrics::ValueObserver<double>> NewDoubleValueObserver( + nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + const bool enabled, + void (*callback)(opentelemetry::metrics::ObserverResult<double>)) override; + + /** + * Utility method that allows users to atomically record measurements to a set of + * synchronous metric instruments with a common set of labels. + * + * @param labels the set of labels to associate with this recorder. + * @param values a span of pairs where the first element of the pair is a metric instrument + * to record to, and the second element is the value to update that instrument with. + */ + void RecordShortBatch( + const opentelemetry::common::KeyValueIterable &labels, + nostd::span<opentelemetry::metrics::SynchronousInstrument<short> *> instruments, + nostd::span<const short> values) noexcept override; + + void RecordIntBatch(const opentelemetry::common::KeyValueIterable &labels, + nostd::span<opentelemetry::metrics::SynchronousInstrument<int> *> instruments, + nostd::span<const int> values) noexcept override; + + void RecordFloatBatch( + const opentelemetry::common::KeyValueIterable &labels, + nostd::span<opentelemetry::metrics::SynchronousInstrument<float> *> instruments, + nostd::span<const float> values) noexcept override; + + void RecordDoubleBatch( + const opentelemetry::common::KeyValueIterable &labels, + nostd::span<opentelemetry::metrics::SynchronousInstrument<double> *> instruments, + nostd::span<const double> values) noexcept override; + + /** + * An SDK-only function that checkpoints the aggregators of all instruments created from + * this meter, creates a {@code Record} out of them, and sends them for export. + * + * @return A vector of {@code Records} to be sent to the processor. + */ + std::vector<Record> Collect() noexcept; + +private: + /** + * A private function that creates records from all synchronous instruments created from + * this meter. + * + * @param records A reference to the vector to push the new records to. + */ + void CollectMetrics(std::vector<Record> &records); + + /** + * Helper function to collect Records from a single synchronous instrument + * + * @tparam T The integral type of the instrument to collect from. + * @param i A map iterator pointing to the instrument to collect from + * @param records The vector to add the new records to. + */ + template <typename T> + void CollectSingleSyncInstrument( + typename std::map<std::string, + std::shared_ptr<opentelemetry::metrics::SynchronousInstrument<T>>>::iterator + i, + std::vector<Record> &records); + + /** + * A private function that creates records from all asynchronous instruments created from + * this meter. + * + * @param records A reference to the vector to push the new records to. + */ + void CollectObservers(std::vector<Record> &records); + + /** + * Helper function to collect Records from a single asynchronous instrument + * + * @tparam T The integral type of the instrument to collect from. + * @param i A map iterator pointing to the instrument to collect from + * @param records The vector to add the new records to. + */ + template <typename T> + void CollectSingleAsyncInstrument( + typename std::map< + std::string, + std::shared_ptr<opentelemetry::metrics::AsynchronousInstrument<T>>>::iterator i, + std::vector<Record> &records); + + /** + * Utility function used by the meter that checks if a user-passed name abides by OpenTelemetry + * naming rules. The rules are as follows: + * 1. The name must not be empty. + * 2. The name must not start with a digit, a space, or any punctuation. + * 3. The name must only have the following chaacters: + * All alphanumeric characters, '.', '_' and '-'. + * + * @param name The name to be examined for legality. + * @return A bool representing whether the name is valid by the OpenTelemetry syntax rules. + */ + bool IsValidName(nostd::string_view name); + + /** + * A utility function used by the meter to determine whether an instrument of a specified + * name already exists in this meter. + * + * @param name The name to examine. + * @return A boolean representing whether the name has already been used by this meter. + */ + bool NameAlreadyUsed(nostd::string_view name); + + /* + * All instruments must be stored in a map so the meter can collect on these instruments. + * Additionally, when creating a new instrument, the meter must check if an instrument of the same + * name already exists. + */ + std::map<std::string, std::shared_ptr<opentelemetry::metrics::SynchronousInstrument<short>>> + short_metrics_; + std::map<std::string, std::shared_ptr<opentelemetry::metrics::SynchronousInstrument<int>>> + int_metrics_; + std::map<std::string, std::shared_ptr<opentelemetry::metrics::SynchronousInstrument<float>>> + float_metrics_; + std::map<std::string, std::shared_ptr<opentelemetry::metrics::SynchronousInstrument<double>>> + double_metrics_; + + std::map<std::string, std::shared_ptr<opentelemetry::metrics::AsynchronousInstrument<short>>> + short_observers_; + std::map<std::string, std::shared_ptr<opentelemetry::metrics::AsynchronousInstrument<int>>> + int_observers_; + std::map<std::string, std::shared_ptr<opentelemetry::metrics::AsynchronousInstrument<float>>> + float_observers_; + std::map<std::string, std::shared_ptr<opentelemetry::metrics::AsynchronousInstrument<double>>> + double_observers_; + + std::unordered_set<std::string> names_; + + std::string library_name_; + std::string library_version_; + + std::mutex metrics_lock_; + std::mutex observers_lock_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/meter_provider.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/meter_provider.h new file mode 100644 index 000000000..da218ceac --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/meter_provider.h @@ -0,0 +1,37 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include "opentelemetry/_metrics/meter_provider.h" +# include "opentelemetry/nostd/shared_ptr.h" +# include "opentelemetry/sdk/_metrics/meter.h" + +# include <memory> +# include <string> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class MeterProvider final : public opentelemetry::metrics::MeterProvider +{ +public: + /** + * Initialize a new meter provider + */ + explicit MeterProvider(std::string library_name = "", std::string library_version = "") noexcept; + + opentelemetry::nostd::shared_ptr<opentelemetry::metrics::Meter> GetMeter( + nostd::string_view library_name, + nostd::string_view library_version = "") noexcept override; + +private: + std::shared_ptr<opentelemetry::metrics::Meter> meter_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/processor.h new file mode 100644 index 000000000..dd6c421fb --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/processor.h @@ -0,0 +1,38 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/nostd/string_view.h" +# include "opentelemetry/sdk/_metrics/record.h" +# include "opentelemetry/version.h" + +# include <iostream> +# include <string> +# include <unordered_map> + +OPENTELEMETRY_BEGIN_NAMESPACE + +namespace sdk +{ +namespace metrics +{ + +class MetricsProcessor +{ +public: + virtual ~MetricsProcessor() = default; + + virtual std::vector<opentelemetry::sdk::metrics::Record> CheckpointSelf() noexcept = 0; + + virtual void FinishedCollection() noexcept = 0; + + virtual void process(opentelemetry::sdk::metrics::Record record) noexcept = 0; +}; + +} // namespace metrics +} // namespace sdk + +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/record.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/record.h new file mode 100644 index 000000000..a07c1595c --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/record.h @@ -0,0 +1,50 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <memory> +# include "opentelemetry/_metrics/instrument.h" +# include "opentelemetry/nostd/variant.h" +# include "opentelemetry/sdk/_metrics/aggregator/aggregator.h" + +OPENTELEMETRY_BEGIN_NAMESPACE + +namespace sdk +{ +namespace metrics +{ +using AggregatorVariant = nostd::variant<std::shared_ptr<Aggregator<short>>, + std::shared_ptr<Aggregator<int>>, + std::shared_ptr<Aggregator<float>>, + std::shared_ptr<Aggregator<double>>>; +class Record +{ +public: + explicit Record(nostd::string_view name, + nostd::string_view description, + std::string labels, + AggregatorVariant aggregator) + { + name_ = std::string(name); + description_ = std::string(description); + labels_ = labels; + aggregator_ = aggregator; + } + + std::string GetName() { return name_; } + std::string GetDescription() { return description_; } + std::string GetLabels() { return labels_; } + AggregatorVariant GetAggregator() { return aggregator_; } + +private: + std::string name_; + std::string description_; + std::string labels_; + AggregatorVariant aggregator_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/sync_instruments.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/sync_instruments.h new file mode 100644 index 000000000..80d9b6092 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/sync_instruments.h @@ -0,0 +1,465 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <map> +# include <memory> +# include <sstream> +# include <stdexcept> +# include <vector> + +# include "opentelemetry/_metrics/sync_instruments.h" +# include "opentelemetry/common/macros.h" +# include "opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h" +# include "opentelemetry/sdk/_metrics/aggregator/min_max_sum_count_aggregator.h" +# include "opentelemetry/sdk/_metrics/instrument.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4250) // inheriting methods via dominance +# endif + +template <class T> +class BoundCounter final : public BoundSynchronousInstrument<T>, + public opentelemetry::metrics::BoundCounter<T> +{ + +public: + BoundCounter() = default; + + BoundCounter(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled) + : BoundSynchronousInstrument<T>( + name, + description, + unit, + enabled, + opentelemetry::metrics::InstrumentKind::Counter, + std::shared_ptr<Aggregator<T>>(new CounterAggregator<T>( + opentelemetry::metrics::InstrumentKind::Counter))) // Aggregator is chosen here + {} + + /* + * Add adds the value to the counter's sum. The labels are already linked to the instrument + * and are not specified. + * + * @param value the numerical representation of the metric being captured + * @param labels the set of labels, as key-value pairs + */ + virtual void add(T value) override + { + if (value < 0) + { +# if __EXCEPTIONS + throw std::invalid_argument("Counter instrument updates must be non-negative."); +# else + std::terminate(); +# endif + } + else + { + this->update(value); + } + } +}; + +template <class T> +class Counter final : public SynchronousInstrument<T>, public opentelemetry::metrics::Counter<T> +{ + +public: + Counter() = default; + + Counter(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled) + : SynchronousInstrument<T>(name, + description, + unit, + enabled, + opentelemetry::metrics::InstrumentKind::Counter) + {} + + /* + * Bind creates a bound instrument for this counter. The labels are + * associated with values recorded via subsequent calls to Record. + * + * @param labels the set of labels, as key-value pairs. + * @return a BoundCounter tied to the specified labels + */ + + virtual nostd::shared_ptr<opentelemetry::metrics::BoundCounter<T>> bindCounter( + const opentelemetry::common::KeyValueIterable &labels) override + { + this->mu_.lock(); + std::string labelset = KvToString(labels); + if (boundInstruments_.find(labelset) == boundInstruments_.end()) + { + auto sp1 = nostd::shared_ptr<opentelemetry::metrics::BoundCounter<T>>( + new BoundCounter<T>(this->name_, this->description_, this->unit_, this->enabled_)); + boundInstruments_[labelset] = sp1; + this->mu_.unlock(); + return sp1; + } + else + { + boundInstruments_[labelset]->inc_ref(); + auto ret = boundInstruments_[labelset]; + this->mu_.unlock(); + return ret; + } + } + + /* + * Add adds the value to the counter's sum. The labels should contain + * the keys and values to be associated with this value. Counters only + * accept positive valued updates. + * + * @param value the numerical representation of the metric being captured + * @param labels the set of labels, as key-value pairs + */ + virtual void add(T value, const opentelemetry::common::KeyValueIterable &labels) override + { + if (value < 0) + { +# if __EXCEPTIONS + throw std::invalid_argument("Counter instrument updates must be non-negative."); +# else + std::terminate(); +# endif + } + else + { + auto sp = bindCounter(labels); + sp->update(value); + sp->unbind(); + } + } + + virtual std::vector<Record> GetRecords() override + { + this->mu_.lock(); + std::vector<Record> ret; + std::vector<std::string> toDelete; + for (const auto &x : boundInstruments_) + { + if (x.second->get_ref() == 0) + { + toDelete.push_back(x.first); + } +# ifdef OPENTELEMETRY_RTTI_ENABLED + auto agg_ptr = dynamic_cast<BoundCounter<T> *>(x.second.get())->GetAggregator(); +# else + auto agg_ptr = static_cast<BoundCounter<T> *>(x.second.get())->GetAggregator(); +# endif + if (agg_ptr->is_updated()) + { + agg_ptr->checkpoint(); + ret.push_back(Record(x.second->GetName(), x.second->GetDescription(), x.first, agg_ptr)); + } + } + for (const auto &x : toDelete) + { + boundInstruments_.erase(x); + } + this->mu_.unlock(); + return ret; + } + + virtual void update(T val, const opentelemetry::common::KeyValueIterable &labels) override + { + add(val, labels); + } + + // A collection of the bound instruments created by this unbound instrument identified by their + // labels. + std::unordered_map<std::string, nostd::shared_ptr<opentelemetry::metrics::BoundCounter<T>>> + boundInstruments_; +}; + +template <class T> +class BoundUpDownCounter final : public BoundSynchronousInstrument<T>, + virtual public opentelemetry::metrics::BoundUpDownCounter<T> +{ + +public: + BoundUpDownCounter() = default; + + BoundUpDownCounter(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled) + : BoundSynchronousInstrument<T>(name, + description, + unit, + enabled, + opentelemetry::metrics::InstrumentKind::UpDownCounter, + std::shared_ptr<Aggregator<T>>(new CounterAggregator<T>( + opentelemetry::metrics::InstrumentKind::UpDownCounter))) + {} + + /* + * Add adds the value to the counter's sum. The labels are already linked to the instrument + * and are not specified. + * + * @param value the numerical representation of the metric being captured + * @param labels the set of labels, as key-value pairs + */ + virtual void add(T value) override { this->update(value); } +}; + +template <class T> +class UpDownCounter final : public SynchronousInstrument<T>, + public opentelemetry::metrics::UpDownCounter<T> +{ + +public: + UpDownCounter() = default; + + UpDownCounter(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled) + : SynchronousInstrument<T>(name, + description, + unit, + enabled, + opentelemetry::metrics::InstrumentKind::UpDownCounter) + {} + + /* + * Bind creates a bound instrument for this counter. The labels are + * associated with values recorded via subsequent calls to Record. + * + * @param labels the set of labels, as key-value pairs. + * @return a BoundIntCounter tied to the specified labels + */ + nostd::shared_ptr<opentelemetry::metrics::BoundUpDownCounter<T>> bindUpDownCounter( + const opentelemetry::common::KeyValueIterable &labels) override + { + this->mu_.lock(); + std::string labelset = KvToString(labels); + if (boundInstruments_.find(labelset) == boundInstruments_.end()) + { + auto sp1 = nostd::shared_ptr<opentelemetry::metrics::BoundUpDownCounter<T>>( + new BoundUpDownCounter<T>(this->name_, this->description_, this->unit_, this->enabled_)); + boundInstruments_[labelset] = sp1; + this->mu_.unlock(); + return sp1; + } + else + { + boundInstruments_[labelset]->inc_ref(); + auto ret = boundInstruments_[labelset]; + this->mu_.unlock(); + return ret; + } + } + + /* + * Add adds the value to the counter's sum. The labels should contain + * the keys and values to be associated with this value. Counters only + * accept positive valued updates. + * + * @param value the numerical representation of the metric being captured + * @param labels the set of labels, as key-value pairs + */ + void add(T value, const opentelemetry::common::KeyValueIterable &labels) override + { + auto sp = bindUpDownCounter(labels); + sp->update(value); + sp->unbind(); + } + + virtual std::vector<Record> GetRecords() override + { + this->mu_.lock(); + std::vector<Record> ret; + std::vector<std::string> toDelete; + for (const auto &x : boundInstruments_) + { + if (x.second->get_ref() == 0) + { + toDelete.push_back(x.first); + } +# ifdef OPENTELEMETRY_RTTI_ENABLED + auto agg_ptr = dynamic_cast<BoundUpDownCounter<T> *>(x.second.get())->GetAggregator(); +# else + auto agg_ptr = static_cast<BoundUpDownCounter<T> *>(x.second.get())->GetAggregator(); +# endif + if (agg_ptr->is_updated()) + { + agg_ptr->checkpoint(); + ret.push_back(Record(x.second->GetName(), x.second->GetDescription(), x.first, agg_ptr)); + } + } + for (const auto &x : toDelete) + { + boundInstruments_.erase(x); + } + this->mu_.unlock(); + return ret; + } + + virtual void update(T val, const opentelemetry::common::KeyValueIterable &labels) override + { + add(val, labels); + } + + std::unordered_map<std::string, nostd::shared_ptr<opentelemetry::metrics::BoundUpDownCounter<T>>> + boundInstruments_; +}; + +template <class T> +class BoundValueRecorder final : public BoundSynchronousInstrument<T>, + public opentelemetry::metrics::BoundValueRecorder<T> +{ + +public: + BoundValueRecorder() = default; + + BoundValueRecorder(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled) + : BoundSynchronousInstrument<T>( + name, + description, + unit, + enabled, + opentelemetry::metrics::InstrumentKind::ValueRecorder, + std::shared_ptr<Aggregator<T>>(new MinMaxSumCountAggregator<T>( + opentelemetry::metrics::InstrumentKind::ValueRecorder))) + {} + + /* + * Add adds the value to the counter's sum. The labels are already linked to the instrument + * and are not specified. + * + * @param value the numerical representation of the metric being captured + * @param labels the set of labels, as key-value pairs + */ + void record(T value) { this->update(value); } +}; + +template <class T> +class ValueRecorder final : public SynchronousInstrument<T>, + public opentelemetry::metrics::ValueRecorder<T> +{ + +public: + ValueRecorder() = default; + + ValueRecorder(nostd::string_view name, + nostd::string_view description, + nostd::string_view unit, + bool enabled) + : SynchronousInstrument<T>(name, + description, + unit, + enabled, + opentelemetry::metrics::InstrumentKind::ValueRecorder) + {} + + /* + * Bind creates a bound instrument for this counter. The labels are + * associated with values recorded via subsequent calls to Record. + * + * @param labels the set of labels, as key-value pairs. + * @return a BoundIntCounter tied to the specified labels + */ + nostd::shared_ptr<opentelemetry::metrics::BoundValueRecorder<T>> bindValueRecorder( + const opentelemetry::common::KeyValueIterable &labels) override + { + this->mu_.lock(); + std::string labelset = KvToString(labels); + if (boundInstruments_.find(labelset) == boundInstruments_.end()) + { + auto sp1 = nostd::shared_ptr<opentelemetry::metrics::BoundValueRecorder<T>>( + new BoundValueRecorder<T>(this->name_, this->description_, this->unit_, this->enabled_)); + boundInstruments_[labelset] = sp1; + this->mu_.unlock(); + return sp1; + } + else + { + boundInstruments_[labelset]->inc_ref(); + auto ret = boundInstruments_[labelset]; + this->mu_.unlock(); + return ret; + } + } + + /* + * Add adds the value to the counter's sum. The labels should contain + * the keys and values to be associated with this value. Counters only + * accept positive valued updates. + * + * @param value the numerical representation of the metric being captured + * @param labels the set of labels, as key-value pairs + */ + void record(T value, const opentelemetry::common::KeyValueIterable &labels) override + { + auto sp = bindValueRecorder(labels); + sp->update(value); + sp->unbind(); + } + + virtual std::vector<Record> GetRecords() override + { + this->mu_.lock(); + std::vector<Record> ret; + std::vector<std::string> toDelete; + for (const auto &x : boundInstruments_) + { + if (x.second->get_ref() == 0) + { + toDelete.push_back(x.first); + } +# ifdef OPENTELEMETRY_RTTI_ENABLED + auto agg_ptr = dynamic_cast<BoundValueRecorder<T> *>(x.second.get())->GetAggregator(); +# else + auto agg_ptr = static_cast<BoundValueRecorder<T> *>(x.second.get())->GetAggregator(); +# endif + if (agg_ptr->is_updated()) + { + agg_ptr->checkpoint(); + ret.push_back(Record(x.second->GetName(), x.second->GetDescription(), x.first, agg_ptr)); + } + } + for (const auto &x : toDelete) + { + boundInstruments_.erase(x); + } + this->mu_.unlock(); + return ret; + } + + virtual void update(T value, const opentelemetry::common::KeyValueIterable &labels) override + { + record(value, labels); + } + + std::unordered_map<std::string, nostd::shared_ptr<opentelemetry::metrics::BoundValueRecorder<T>>> + boundInstruments_; +}; + +# if defined(_MSC_VER) +# pragma warning(pop) +# endif + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/ungrouped_processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/ungrouped_processor.h new file mode 100644 index 000000000..cc13ae52b --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/_metrics/ungrouped_processor.h @@ -0,0 +1,365 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_METRICS_PREVIEW + +# include <map> + +# include "opentelemetry/common/macros.h" +# include "opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h" +# include "opentelemetry/sdk/_metrics/aggregator/exact_aggregator.h" +# include "opentelemetry/sdk/_metrics/aggregator/gauge_aggregator.h" +# include "opentelemetry/sdk/_metrics/aggregator/histogram_aggregator.h" +# include "opentelemetry/sdk/_metrics/aggregator/min_max_sum_count_aggregator.h" +# include "opentelemetry/sdk/_metrics/aggregator/sketch_aggregator.h" +# include "opentelemetry/sdk/_metrics/processor.h" +# include "opentelemetry/sdk/_metrics/record.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE + +namespace sdk +{ + +namespace metrics +{ + +struct KeyStruct +{ + std::string name; + std::string description; + std::string labels; + opentelemetry::metrics::InstrumentKind ins_kind; + + // constructor + KeyStruct(std::string name, + std::string description, + std::string labels, + opentelemetry::metrics::InstrumentKind ins_kind) + { + this->name = name; + this->description = description; + this->labels = labels; + this->ins_kind = ins_kind; + } + + // operator== is required to compare keys in case of hash collision + bool operator==(const KeyStruct &p) const + { + return name == p.name && description == p.description && labels == p.labels && + ins_kind == p.ins_kind; + } +}; + +struct KeyStruct_Hash +{ + std::size_t operator()(const KeyStruct &keystruct) const + { + std::size_t name_size = keystruct.name.length(); + std::size_t desc_size = keystruct.description.length(); + std::size_t labels_size = keystruct.labels.length(); + std::size_t ins_size = (int)keystruct.ins_kind; + + return (name_size ^ desc_size ^ labels_size) + ins_size; + } +}; + +class UngroupedMetricsProcessor : public MetricsProcessor +{ +public: + explicit UngroupedMetricsProcessor(bool stateful); + + std::vector<opentelemetry::sdk::metrics::Record> CheckpointSelf() noexcept override; + + virtual void FinishedCollection() noexcept override; + + virtual void process(opentelemetry::sdk::metrics::Record record) noexcept override; + +private: + bool stateful_; + std::unordered_map<KeyStruct, opentelemetry::sdk::metrics::AggregatorVariant, KeyStruct_Hash> + batch_map_; + + /** + * get_instrument returns the instrument from the passed in AggregatorVariant. We have to + * unpack the variant then get the instrument from the Aggreagtor. + */ + opentelemetry::metrics::InstrumentKind get_instrument( + opentelemetry::sdk::metrics::AggregatorVariant aggregator) + { + if (nostd::holds_alternative<std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<short>>>( + aggregator)) + { + return nostd::get<std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<short>>>(aggregator) + ->get_instrument_kind(); + } + else if (nostd::holds_alternative< + std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<int>>>(aggregator)) + { + return nostd::get<std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<int>>>(aggregator) + ->get_instrument_kind(); + } + else if (nostd::holds_alternative< + std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<float>>>(aggregator)) + { + return nostd::get<std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<float>>>(aggregator) + ->get_instrument_kind(); + } + else if (nostd::holds_alternative< + std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<double>>>(aggregator)) + { + return nostd::get<std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<double>>>( + aggregator) + ->get_instrument_kind(); + } + + return opentelemetry::metrics::InstrumentKind::Counter; + } + + /** + * aggregator_copy creates a copy of the aggregtor passed through process() for a + * stateful processor. For Sketch, Histogram and Exact we also need to pass in + * additional constructor values + */ + template <typename T> + std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>> aggregator_copy( + std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>> aggregator) + { + auto ins_kind = aggregator->get_instrument_kind(); + auto agg_kind = aggregator->get_aggregator_kind(); + + switch (agg_kind) + { + case opentelemetry::sdk::metrics::AggregatorKind::Counter: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::CounterAggregator<T>(ins_kind)); + + case opentelemetry::sdk::metrics::AggregatorKind::MinMaxSumCount: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>(ins_kind)); + + case opentelemetry::sdk::metrics::AggregatorKind::Gauge: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::GaugeAggregator<T>(ins_kind)); + + case opentelemetry::sdk::metrics::AggregatorKind::Sketch: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::SketchAggregator<T>( + ins_kind, aggregator->get_error_bound(), aggregator->get_max_buckets())); + + case opentelemetry::sdk::metrics::AggregatorKind::Histogram: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::HistogramAggregator<T>(ins_kind, + aggregator->get_boundaries())); + + case opentelemetry::sdk::metrics::AggregatorKind::Exact: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::ExactAggregator<T>( + ins_kind, aggregator->get_quant_estimation())); + + default: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::CounterAggregator<T>(ins_kind)); + } + }; + + /** + * aggregator_for will return an Aggregator based off the instrument passed in. This should be + * the function that we assign Aggreagtors for instruments, but is currently unused in our + * pipeline. + */ + template <typename T> + std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>> aggregator_for( + opentelemetry::metrics::InstrumentKind ins_kind) + { + switch (ins_kind) + { + case opentelemetry::metrics::InstrumentKind::Counter: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::CounterAggregator<T>(ins_kind)); + + case opentelemetry::metrics::InstrumentKind::UpDownCounter: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::CounterAggregator<T>(ins_kind)); + + case opentelemetry::metrics::InstrumentKind::ValueRecorder: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>(ins_kind)); + + case opentelemetry::metrics::InstrumentKind::SumObserver: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::CounterAggregator<T>(ins_kind)); + + case opentelemetry::metrics::InstrumentKind::UpDownSumObserver: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::CounterAggregator<T>(ins_kind)); + + case opentelemetry::metrics::InstrumentKind::ValueObserver: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>(ins_kind)); + + default: + return std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>( + new opentelemetry::sdk::metrics::CounterAggregator<T>(ins_kind)); + } + }; + + /** + * merge_aggreagtors takes in two shared pointers to aggregators of the same kind. + * We first need to dynamically cast to the actual Aggregator that is held in the + * Aggregator<T> wrapper. Then we must get the underlying pointer from the shared + * pointer and merge them together. + */ + template <typename T> + void merge_aggregators(std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>> batch_agg, + std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>> record_agg) + { + auto agg_kind = batch_agg->get_aggregator_kind(); + if (agg_kind == opentelemetry::sdk::metrics::AggregatorKind::Counter) + { +# ifdef OPENTELEMETRY_RTTI_ENABLED + std::shared_ptr<opentelemetry::sdk::metrics::CounterAggregator<T>> temp_batch_agg_counter = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::CounterAggregator<T>>(batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::CounterAggregator<T>> temp_record_agg_counter = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::CounterAggregator<T>>(record_agg); +# else + std::shared_ptr<opentelemetry::sdk::metrics::CounterAggregator<T>> temp_batch_agg_counter = + std::static_pointer_cast<opentelemetry::sdk::metrics::CounterAggregator<T>>(batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::CounterAggregator<T>> temp_record_agg_counter = + std::static_pointer_cast<opentelemetry::sdk::metrics::CounterAggregator<T>>(record_agg); +# endif + auto temp_batch_agg_raw_counter = temp_batch_agg_counter.get(); + auto temp_record_agg_raw_counter = temp_record_agg_counter.get(); + + temp_batch_agg_raw_counter->merge(*temp_record_agg_raw_counter); + } + else if (agg_kind == opentelemetry::sdk::metrics::AggregatorKind::MinMaxSumCount) + { +# ifdef OPENTELEMETRY_RTTI_ENABLED + std::shared_ptr<opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>> + temp_batch_agg_mmsc = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>>( + batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>> + temp_record_agg_mmsc = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>>( + record_agg); +# else + std::shared_ptr<opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>> + temp_batch_agg_mmsc = + std::static_pointer_cast<opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>>( + batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>> + temp_record_agg_mmsc = + std::static_pointer_cast<opentelemetry::sdk::metrics::MinMaxSumCountAggregator<T>>( + record_agg); +# endif + + auto temp_batch_agg_raw_mmsc = temp_batch_agg_mmsc.get(); + auto temp_record_agg_raw_mmsc = temp_record_agg_mmsc.get(); + + temp_batch_agg_raw_mmsc->merge(*temp_record_agg_raw_mmsc); + } + else if (agg_kind == opentelemetry::sdk::metrics::AggregatorKind::Gauge) + { +# ifdef OPENTELEMETRY_RTTI_ENABLED + std::shared_ptr<opentelemetry::sdk::metrics::GaugeAggregator<T>> temp_batch_agg_gauge = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::GaugeAggregator<T>>(batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::GaugeAggregator<T>> temp_record_agg_gauge = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::GaugeAggregator<T>>(record_agg); +# else + std::shared_ptr<opentelemetry::sdk::metrics::GaugeAggregator<T>> temp_batch_agg_gauge = + std::static_pointer_cast<opentelemetry::sdk::metrics::GaugeAggregator<T>>(batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::GaugeAggregator<T>> temp_record_agg_gauge = + std::static_pointer_cast<opentelemetry::sdk::metrics::GaugeAggregator<T>>(record_agg); +# endif + + auto temp_batch_agg_raw_gauge = temp_batch_agg_gauge.get(); + auto temp_record_agg_raw_gauge = temp_record_agg_gauge.get(); + + temp_batch_agg_raw_gauge->merge(*temp_record_agg_raw_gauge); + } + else if (agg_kind == opentelemetry::sdk::metrics::AggregatorKind::Sketch) + { +# ifdef OPENTELEMETRY_RTTI_ENABLED + std::shared_ptr<opentelemetry::sdk::metrics::SketchAggregator<T>> temp_batch_agg_sketch = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::SketchAggregator<T>>(batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::SketchAggregator<T>> temp_record_agg_sketch = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::SketchAggregator<T>>(record_agg); +# else + std::shared_ptr<opentelemetry::sdk::metrics::SketchAggregator<T>> temp_batch_agg_sketch = + std::static_pointer_cast<opentelemetry::sdk::metrics::SketchAggregator<T>>(batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::SketchAggregator<T>> temp_record_agg_sketch = + std::static_pointer_cast<opentelemetry::sdk::metrics::SketchAggregator<T>>(record_agg); +# endif + auto temp_batch_agg_raw_sketch = temp_batch_agg_sketch.get(); + auto temp_record_agg_raw_sketch = temp_record_agg_sketch.get(); + + temp_batch_agg_raw_sketch->merge(*temp_record_agg_raw_sketch); + } + else if (agg_kind == opentelemetry::sdk::metrics::AggregatorKind::Histogram) + { +# ifdef OPENTELEMETRY_RTTI_ENABLED + std::shared_ptr<opentelemetry::sdk::metrics::HistogramAggregator<T>> + temp_batch_agg_histogram = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::HistogramAggregator<T>>( + batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::HistogramAggregator<T>> + temp_record_agg_histogram = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::HistogramAggregator<T>>( + record_agg); +# else + std::shared_ptr<opentelemetry::sdk::metrics::HistogramAggregator<T>> + temp_batch_agg_histogram = + std::static_pointer_cast<opentelemetry::sdk::metrics::HistogramAggregator<T>>( + batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::HistogramAggregator<T>> + temp_record_agg_histogram = + std::static_pointer_cast<opentelemetry::sdk::metrics::HistogramAggregator<T>>( + record_agg); +# endif + + auto temp_batch_agg_raw_histogram = temp_batch_agg_histogram.get(); + auto temp_record_agg_raw_histogram = temp_record_agg_histogram.get(); + + temp_batch_agg_raw_histogram->merge(*temp_record_agg_raw_histogram); + } + else if (agg_kind == opentelemetry::sdk::metrics::AggregatorKind::Exact) + { +# ifdef OPENTELEMETRY_RTTI_ENABLED + std::shared_ptr<opentelemetry::sdk::metrics::ExactAggregator<T>> temp_batch_agg_exact = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::ExactAggregator<T>>(batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::ExactAggregator<T>> temp_record_agg_exact = + std::dynamic_pointer_cast<opentelemetry::sdk::metrics::ExactAggregator<T>>(record_agg); +# else + std::shared_ptr<opentelemetry::sdk::metrics::ExactAggregator<T>> temp_batch_agg_exact = + std::static_pointer_cast<opentelemetry::sdk::metrics::ExactAggregator<T>>(batch_agg); + + std::shared_ptr<opentelemetry::sdk::metrics::ExactAggregator<T>> temp_record_agg_exact = + std::static_pointer_cast<opentelemetry::sdk::metrics::ExactAggregator<T>>(record_agg); +# endif + + auto temp_batch_agg_raw_exact = temp_batch_agg_exact.get(); + auto temp_record_agg_raw_exact = temp_record_agg_exact.get(); + + temp_batch_agg_raw_exact->merge(*temp_record_agg_raw_exact); + } + } +}; +} // namespace metrics +} // namespace sdk + +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/atomic_shared_ptr.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/atomic_shared_ptr.h new file mode 100644 index 000000000..07e19ac0f --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/atomic_shared_ptr.h @@ -0,0 +1,62 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <atomic> +#include <memory> +#include <mutex> +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace common +{ +/** + * A wrapper to provide atomic shared pointers. + * + * This wrapper relies on a mutex for gcc 4.8, and specializations of + * std::atomic_store and std::atomic_load for all other instances. + */ +#if (__GNUC__ == 4 && (__GNUC_MINOR__ >= 8)) +template <class T> +class AtomicSharedPtr +{ +public: + explicit AtomicSharedPtr(std::shared_ptr<T> ptr) noexcept : ptr_{std::move(ptr)} {} + + void store(const std::shared_ptr<T> &other) noexcept + { + std::lock_guard<std::mutex> lock_guard{mu_}; + ptr_ = other; + } + + std::shared_ptr<T> load() const noexcept + { + std::lock_guard<std::mutex> lock_guard{mu_}; + return ptr_; + } + +private: + std::shared_ptr<T> ptr_; + mutable std::mutex mu_; +}; +#else +template <class T> +class AtomicSharedPtr +{ +public: + explicit AtomicSharedPtr(std::shared_ptr<T> ptr) noexcept : ptr_{std::move(ptr)} {} + + void store(const std::shared_ptr<T> &other) noexcept { std::atomic_store(&ptr_, other); } + + std::shared_ptr<T> load() const noexcept { return std::atomic_load(&ptr_); } + +private: + std::shared_ptr<T> ptr_; +}; +#endif +} // namespace common +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/atomic_unique_ptr.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/atomic_unique_ptr.h new file mode 100644 index 000000000..5945df98c --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/atomic_unique_ptr.h @@ -0,0 +1,87 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <atomic> +#include <memory> + +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace common +{ +/** + * An owning pointer similar to std::unique_ptr but with methods for atomic + * operations. + */ +template <class T> +class AtomicUniquePtr +{ +public: + AtomicUniquePtr() noexcept {} + + explicit AtomicUniquePtr(std::unique_ptr<T> &&other) noexcept : ptr_(other.release()) {} + + ~AtomicUniquePtr() noexcept { Reset(); } + + T &operator*() const noexcept { return *Get(); } + + T *operator->() const noexcept { return Get(); } + + /** + * @return the underly pointer managed. + */ + T *Get() const noexcept { return ptr_; } + + /** + * @return true if the pointer is null + */ + bool IsNull() const noexcept { return ptr_.load() == nullptr; } + + /** + * Atomically swap the pointer only if it's null. + * @param owner the pointer to swap with + * @return true if the swap was successful + */ + bool SwapIfNull(std::unique_ptr<T> &owner) noexcept + { + auto ptr = owner.get(); + T *expected = nullptr; + auto was_successful = ptr_.compare_exchange_weak(expected, ptr, std::memory_order_release, + std::memory_order_relaxed); + if (was_successful) + { + owner.release(); + return true; + } + return false; + } + + /** + * Atomically swap the pointer with another. + * @param ptr the pointer to swap with + */ + void Swap(std::unique_ptr<T> &other) noexcept { other.reset(ptr_.exchange(other.release())); } + + /** + * Set the pointer to a new value and delete the current value if non-null. + * @param ptr the new pointer value to set + */ + void Reset(T *ptr = nullptr) noexcept + { + ptr = ptr_.exchange(ptr); + if (ptr != nullptr) + { + delete ptr; + } + } + +private: + std::atomic<T *> ptr_{nullptr}; +}; +} // namespace common +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/attribute_utils.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/attribute_utils.h new file mode 100644 index 000000000..68b09f044 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/attribute_utils.h @@ -0,0 +1,199 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <map> +#include <string> +#include <unordered_map> +#include <vector> +#include "opentelemetry/common/attribute_value.h" +#include "opentelemetry/common/key_value_iterable_view.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace common +{ +/** + * A counterpart to AttributeValue that makes sure a value is owned. This + * replaces all non-owning references with owned copies. + * + * The following types are not currently supported by the OpenTelemetry + * specification, but reserved for future use: + * - uint64_t + * - std::vector<uint64_t> + * - std::vector<uint8_t> + */ +using OwnedAttributeValue = nostd::variant<bool, + int32_t, + uint32_t, + int64_t, + double, + std::string, + std::vector<bool>, + std::vector<int32_t>, + std::vector<uint32_t>, + std::vector<int64_t>, + std::vector<double>, + std::vector<std::string>, + uint64_t, + std::vector<uint64_t>, + std::vector<uint8_t>>; + +enum OwnedAttributeType +{ + kTypeBool, + kTypeInt, + kTypeUInt, + kTypeInt64, + kTypeDouble, + kTypeString, + kTypeSpanBool, + kTypeSpanInt, + kTypeSpanUInt, + kTypeSpanInt64, + kTypeSpanDouble, + kTypeSpanString, + kTypeUInt64, + kTypeSpanUInt64, + kTypeSpanByte +}; + +/** + * Creates an owned copy (OwnedAttributeValue) of a non-owning AttributeValue. + */ +struct AttributeConverter +{ + OwnedAttributeValue operator()(bool v) { return OwnedAttributeValue(v); } + OwnedAttributeValue operator()(int32_t v) { return OwnedAttributeValue(v); } + OwnedAttributeValue operator()(uint32_t v) { return OwnedAttributeValue(v); } + OwnedAttributeValue operator()(int64_t v) { return OwnedAttributeValue(v); } + OwnedAttributeValue operator()(uint64_t v) { return OwnedAttributeValue(v); } + OwnedAttributeValue operator()(double v) { return OwnedAttributeValue(v); } + OwnedAttributeValue operator()(nostd::string_view v) + { + return OwnedAttributeValue(std::string(v)); + } + OwnedAttributeValue operator()(std::string v) { return OwnedAttributeValue(v); } + OwnedAttributeValue operator()(const char *v) { return OwnedAttributeValue(std::string(v)); } + OwnedAttributeValue operator()(nostd::span<const uint8_t> v) { return convertSpan<uint8_t>(v); } + OwnedAttributeValue operator()(nostd::span<const bool> v) { return convertSpan<bool>(v); } + OwnedAttributeValue operator()(nostd::span<const int32_t> v) { return convertSpan<int32_t>(v); } + OwnedAttributeValue operator()(nostd::span<const uint32_t> v) { return convertSpan<uint32_t>(v); } + OwnedAttributeValue operator()(nostd::span<const int64_t> v) { return convertSpan<int64_t>(v); } + OwnedAttributeValue operator()(nostd::span<const uint64_t> v) { return convertSpan<uint64_t>(v); } + OwnedAttributeValue operator()(nostd::span<const double> v) { return convertSpan<double>(v); } + OwnedAttributeValue operator()(nostd::span<const nostd::string_view> v) + { + return convertSpan<std::string>(v); + } + + template <typename T, typename U = T> + OwnedAttributeValue convertSpan(nostd::span<const U> vals) + { + const std::vector<T> copy(vals.begin(), vals.end()); + return OwnedAttributeValue(std::move(copy)); + } +}; + +/** + * Class for storing attributes. + */ +class AttributeMap : public std::unordered_map<std::string, OwnedAttributeValue> +{ +public: + // Contruct empty attribute map + AttributeMap() : std::unordered_map<std::string, OwnedAttributeValue>(){}; + + // Contruct attribute map and populate with attributes + AttributeMap(const opentelemetry::common::KeyValueIterable &attributes) : AttributeMap() + { + attributes.ForEachKeyValue( + [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept { + SetAttribute(key, value); + return true; + }); + } + + // Construct map from initializer list by applying `SetAttribute` transform for every attribute + AttributeMap( + std::initializer_list<std::pair<nostd::string_view, opentelemetry::common::AttributeValue>> + attributes) + : AttributeMap() + { + for (auto &kv : attributes) + { + SetAttribute(kv.first, kv.second); + } + } + + // Returns a reference to this map + const std::unordered_map<std::string, OwnedAttributeValue> &GetAttributes() const noexcept + { + return (*this); + } + + // Convert non-owning key-value to owning std::string(key) and OwnedAttributeValue(value) + void SetAttribute(nostd::string_view key, + const opentelemetry::common::AttributeValue &value) noexcept + { + (*this)[std::string(key)] = nostd::visit(converter_, value); + } + +private: + AttributeConverter converter_; +}; + +/** + * Class for storing attributes. + */ +class OrderedAttributeMap : public std::map<std::string, OwnedAttributeValue> +{ +public: + // Contruct empty attribute map + OrderedAttributeMap() : std::map<std::string, OwnedAttributeValue>(){}; + + // Contruct attribute map and populate with attributes + OrderedAttributeMap(const opentelemetry::common::KeyValueIterable &attributes) + : OrderedAttributeMap() + { + attributes.ForEachKeyValue( + [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept { + SetAttribute(key, value); + return true; + }); + } + + // Construct map from initializer list by applying `SetAttribute` transform for every attribute + OrderedAttributeMap( + std::initializer_list<std::pair<nostd::string_view, opentelemetry::common::AttributeValue>> + attributes) + : OrderedAttributeMap() + { + for (auto &kv : attributes) + { + SetAttribute(kv.first, kv.second); + } + } + + // Returns a reference to this map + const std::map<std::string, OwnedAttributeValue> &GetAttributes() const noexcept + { + return (*this); + } + + // Convert non-owning key-value to owning std::string(key) and OwnedAttributeValue(value) + void SetAttribute(nostd::string_view key, + const opentelemetry::common::AttributeValue &value) noexcept + { + (*this)[std::string(key)] = nostd::visit(converter_, value); + } + +private: + AttributeConverter converter_; +}; + +} // namespace common +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/attributemap_hash.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/attributemap_hash.h new file mode 100644 index 000000000..573f57eb1 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/attributemap_hash.h @@ -0,0 +1,62 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <iostream> +#include <string> +#include "opentelemetry/sdk/common/attribute_utils.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace common +{ + +template <class T> +inline void GetHashForAttributeValue(size_t &seed, const T arg) +{ + std::hash<T> hasher; + // reference - + // https://www.boost.org/doc/libs/1_37_0/doc/html/hash/reference.html#boost.hash_combine + seed ^= hasher(arg) + 0x9e3779b9 + (seed << 6) + (seed >> 2); +} + +template <class T> +inline void GetHashForAttributeValue(size_t &seed, const std::vector<T> &arg) +{ + for (auto v : arg) + { + GetHashForAttributeValue<T>(seed, v); + } +} + +struct GetHashForAttributeValueVisitor +{ + GetHashForAttributeValueVisitor(size_t &seed) : seed_(seed) {} + template <class T> + void operator()(T &v) + { + GetHashForAttributeValue(seed_, v); + } + size_t &seed_; +}; + +// Calculate hash of keys and values of attribute map +inline size_t GetHashForAttributeMap(const OrderedAttributeMap &attribute_map) +{ + size_t seed = 0UL; + for (auto &kv : attribute_map) + { + std::hash<std::string> hasher; + // reference - + // https://www.boost.org/doc/libs/1_37_0/doc/html/hash/reference.html#boost.hash_combine + seed ^= hasher(kv.first) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + nostd::visit(GetHashForAttributeValueVisitor(seed), kv.second); + } + return seed; +} + +} // namespace common +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/circular_buffer.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/circular_buffer.h new file mode 100644 index 000000000..6af900183 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/circular_buffer.h @@ -0,0 +1,186 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <atomic> +#include <cstdint> +#include <memory> + +#include "opentelemetry/sdk/common/atomic_unique_ptr.h" +#include "opentelemetry/sdk/common/circular_buffer_range.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace common +{ +/* + * A lock-free circular buffer that supports multiple concurrent producers + * and a single consumer. + */ +template <class T> +class CircularBuffer +{ +public: + explicit CircularBuffer(size_t max_size) + : data_{new AtomicUniquePtr<T>[max_size + 1]}, capacity_{max_size + 1} + {} + + /** + * @return a range of the elements in the circular buffer + * + * Note: This method must only be called from the consumer thread. + */ + CircularBufferRange<const AtomicUniquePtr<T>> Peek() const noexcept + { + return const_cast<CircularBuffer *>(this)->PeekImpl(); + } + + /** + * Consume elements from the circular buffer's tail. + * @param n the number of elements to consume + * @param callback the callback to invoke with an AtomicUniquePtr to each + * consumed element. + * + * Note: The callback must set the passed AtomicUniquePtr to null. + * + * Note: This method must only be called from the consumer thread. + */ + template <class Callback> + void Consume(size_t n, Callback callback) noexcept + { + assert(n <= static_cast<size_t>(head_ - tail_)); + auto range = PeekImpl().Take(n); + static_assert(noexcept(callback(range)), "callback not allowed to throw"); + tail_ += n; + callback(range); + } + + /** + * Consume elements from the circular buffer's tail. + * @param n the number of elements to consume + * + * Note: This method must only be called from the consumer thread. + */ + void Consume(size_t n) noexcept + { + Consume(n, [](CircularBufferRange<AtomicUniquePtr<T>> &range) noexcept { + range.ForEach([](AtomicUniquePtr<T> &ptr) noexcept { + ptr.Reset(); + return true; + }); + }); + } + + /** + * Adds an element into the circular buffer. + * @param ptr a pointer to the element to add + * @return true if the element was successfully added; false, otherwise. + */ + bool Add(std::unique_ptr<T> &ptr) noexcept + { + while (true) + { + uint64_t tail = tail_; + uint64_t head = head_; + + // The circular buffer is full, so return false. + if (head - tail >= capacity_ - 1) + { + return false; + } + + uint64_t head_index = head % capacity_; + if (data_[head_index].SwapIfNull(ptr)) + { + auto new_head = head + 1; + auto expected_head = head; + if (head_.compare_exchange_weak(expected_head, new_head, std::memory_order_release, + std::memory_order_relaxed)) + { + // free the swapped out value + ptr.reset(); + + return true; + } + + // If we reached this point (unlikely), it means that between the last + // iteration elements were added and then consumed from the circular + // buffer, so we undo the swap and attempt to add again. + data_[head_index].Swap(ptr); + } + } + return true; + } + + /** + * Clear the circular buffer. + * + * Note: This method must only be called from the consumer thread. + */ + void Clear() noexcept { Consume(size()); } + + /** + * @return the maximum number of bytes that can be stored in the buffer. + */ + size_t max_size() const noexcept { return capacity_ - 1; } + + /** + * @return true if the buffer is empty. + */ + bool empty() const noexcept { return head_ == tail_; } + + /** + * @return the number of bytes stored in the circular buffer. + * + * Note: this method will only return a correct snapshot of the size if called + * from the consumer thread. + */ + size_t size() const noexcept + { + uint64_t tail = tail_; + uint64_t head = head_; + assert(tail <= head); + return head - tail; + } + + /** + * @return the number of elements consumed from the circular buffer. + */ + uint64_t consumption_count() const noexcept { return tail_; } + + /** + * @return the number of elements added to the circular buffer. + */ + uint64_t production_count() const noexcept { return head_; } + +private: + std::unique_ptr<AtomicUniquePtr<T>[]> data_; + size_t capacity_; + std::atomic<uint64_t> head_{0}; + std::atomic<uint64_t> tail_{0}; + + CircularBufferRange<AtomicUniquePtr<T>> PeekImpl() noexcept + { + uint64_t tail_index = tail_ % capacity_; + uint64_t head_index = head_ % capacity_; + if (head_index == tail_index) + { + return {}; + } + auto data = data_.get(); + if (tail_index < head_index) + { + return CircularBufferRange<AtomicUniquePtr<T>>{nostd::span<AtomicUniquePtr<T>>{ + data + tail_index, static_cast<std::size_t>(head_index - tail_index)}}; + } + return {nostd::span<AtomicUniquePtr<T>>{data + tail_index, + static_cast<std::size_t>(capacity_ - tail_index)}, + nostd::span<AtomicUniquePtr<T>>{data, static_cast<std::size_t>(head_index)}}; + } +}; +} // namespace common +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/circular_buffer_range.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/circular_buffer_range.h new file mode 100644 index 000000000..9ef3b66be --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/circular_buffer_range.h @@ -0,0 +1,93 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <cassert> +#include <iterator> +#include <type_traits> +#include <utility> + +#include "opentelemetry/nostd/span.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace common +{ +/** + * A non-owning view into a range of elements in a circular buffer. + */ +template <class T> +class CircularBufferRange +{ +public: + CircularBufferRange() noexcept = default; + + explicit CircularBufferRange(nostd::span<T> first) noexcept : first_{first} {} + + CircularBufferRange(nostd::span<T> first, nostd::span<T> second) noexcept + : first_{first}, second_{second} + {} + + operator CircularBufferRange<const T>() const noexcept { return {first_, second_}; } + + /** + * Iterate over the elements in the range. + * @param callback the callback to call for each element + * @return true if we iterated over all elements + */ + template <class Callback> + bool ForEach(Callback callback) const + noexcept(noexcept(std::declval<Callback>()(std::declval<T &>()))) + { + for (auto &value : first_) + { + if (!callback(value)) + { + return false; + } + } + for (auto &value : second_) + { + if (!callback(value)) + { + return false; + } + } + return true; + } + + /** + * @return the number of elements in the range + */ + size_t size() const noexcept { return first_.size() + second_.size(); } + + /** + * @return true if the range is empty + */ + bool empty() const noexcept { return first_.empty(); } + + /** + * Return a subrange taken from the start of this range. + * @param n the number of element to take in the subrange + * @return a subrange of the first n elements in this range + */ + CircularBufferRange Take(size_t n) const noexcept + { + assert(n <= size()); + if (first_.size() >= n) + { + return CircularBufferRange{nostd::span<T>{first_.data(), n}}; + } + return {first_, nostd::span<T>{second_.data(), n - first_.size()}}; + } + +private: + nostd::span<T> first_; + nostd::span<T> second_; +}; +} // namespace common +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/empty_attributes.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/empty_attributes.h new file mode 100644 index 000000000..4f740bf10 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/empty_attributes.h @@ -0,0 +1,34 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/common/key_value_iterable_view.h" +#include "opentelemetry/common/macros.h" + +#include <array> +#include <map> +#include <string> +#include <utility> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +/** + * Maintain a static empty array of pairs that represents empty (default) attributes. + * This helps to avoid constructing a new empty container every time a call is made + * with default attributes. + */ +OPENTELEMETRY_MAYBE_UNUSED static const opentelemetry::common::KeyValueIterableView< + std::array<std::pair<std::string, int>, 0>> + &GetEmptyAttributes() noexcept +{ + static const std::array<std::pair<std::string, int>, 0> array{}; + static const opentelemetry::common::KeyValueIterableView< + std::array<std::pair<std::string, int>, 0>> + kEmptyAttributes(array); + + return kEmptyAttributes; +} +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/env_variables.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/env_variables.h new file mode 100644 index 000000000..be955ee86 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/env_variables.h @@ -0,0 +1,53 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <string> +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace common +{ + +#if defined(_MSC_VER) +inline int setenv(const char *name, const char *value, int) +{ + return _putenv_s(name, value); +} + +inline int unsetenv(const char *name) +{ + return setenv(name, "", 1); +} +#endif + +// Returns the env variable set. +inline const std::string GetEnvironmentVariable(const char *env_var_name) +{ +#if !defined(NO_GETENV) + const char *endpoint_from_env = nullptr; +# if defined(_MSC_VER) + // avoid calling std::getenv which is deprecated in MSVC. + size_t required_size = 0; + getenv_s(&required_size, nullptr, 0, env_var_name); + std::unique_ptr<char> endpoint_buffer; + if (required_size > 0) + { + endpoint_buffer = std::unique_ptr<char>{new char[required_size]}; + getenv_s(&required_size, endpoint_buffer.get(), required_size, env_var_name); + endpoint_from_env = endpoint_buffer.get(); + } +# else + endpoint_from_env = std::getenv(env_var_name); +# endif // defined(_MSC_VER) + return endpoint_from_env == nullptr ? std::string{} : std::string{endpoint_from_env}; +#else + return std::string{}; +#endif // !defined(NO_GETENV) +} +} // namespace common +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/exporter_utils.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/exporter_utils.h new file mode 100644 index 000000000..091f481f9 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/exporter_utils.h @@ -0,0 +1,34 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace common +{ +/** + * ExportResult is returned as result of exporting a batch of Records. + */ +enum class ExportResult +{ + // Batch was exported successfully. + kSuccess = 0, + + // Batch exporting failed, caller must not retry exporting the same batch + // and the batch must be dropped. + kFailure = 1, + + // The collection does not have enough space to receive the export batch. + kFailureFull = 2, + + // The export() function was passed an invalid argument. + kFailureInvalidArgument = 3 +}; + +} // namespace common +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/global_log_handler.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/global_log_handler.h new file mode 100644 index 000000000..99cf48b82 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/common/global_log_handler.h @@ -0,0 +1,222 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <iostream> +#include <sstream> +#include <utility> + +#include "opentelemetry/nostd/shared_ptr.h" +#include "opentelemetry/sdk/common/attribute_utils.h" +#include "opentelemetry/version.h" + +#define OTEL_INTERNAL_LOG_LEVEL_ERROR 0 +#define OTEL_INTERNAL_LOG_LEVEL_WARN 1 +#define OTEL_INTERNAL_LOG_LEVEL_INFO 2 +#define OTEL_INTERNAL_LOG_LEVEL_DEBUG 3 +#ifndef OTEL_INTERNAL_LOG_LEVEL +// DEBUG by default, we can change log level on runtime +# define OTEL_INTERNAL_LOG_LEVEL OTEL_INTERNAL_LOG_LEVEL_DEBUG +#endif + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace common +{ +namespace internal_log +{ + +enum class LogLevel +{ + Error = 0, + Warning, + Info, + Debug +}; + +inline std::string LevelToString(LogLevel level) +{ + switch (level) + { + case LogLevel::Error: + return "Error"; + case LogLevel::Warning: + return "Warning"; + case LogLevel::Info: + return "Info"; + case LogLevel::Debug: + return "Debug"; + } + return {}; +} + +class LogHandler +{ +public: + virtual ~LogHandler(); + + virtual void Handle(LogLevel level, + const char *file, + int line, + const char *msg, + const sdk::common::AttributeMap &attributes) noexcept = 0; +}; + +class DefaultLogHandler : public LogHandler +{ +public: + void Handle(LogLevel level, + const char *file, + int line, + const char *msg, + const sdk::common::AttributeMap &attributes) noexcept override; +}; + +class NoopLogHandler : public LogHandler +{ +public: + void Handle(LogLevel level, + const char *file, + int line, + const char *msg, + const sdk::common::AttributeMap &error_attributes) noexcept override; +}; + +/** + * Stores the singleton global LogHandler. + */ +class GlobalLogHandler +{ +public: + /** + * Returns the singleton LogHandler. + * + * By default, a default LogHandler is returned. + */ + static inline const nostd::shared_ptr<LogHandler> &GetLogHandler() noexcept + { + return GetHandlerAndLevel().first; + } + + /** + * Changes the singleton LogHandler. + * This should be called once at the start of application before creating any Provider + * instance. + */ + static inline void SetLogHandler(nostd::shared_ptr<LogHandler> eh) noexcept + { + GetHandlerAndLevel().first = eh; + } + + /** + * Returns the singleton log level. + * + * By default, a default log level is returned. + */ + static inline LogLevel GetLogLevel() noexcept { return GetHandlerAndLevel().second; } + + /** + * Changes the singleton Log level. + * This should be called once at the start of application before creating any Provider + * instance. + */ + static inline void SetLogLevel(LogLevel level) noexcept { GetHandlerAndLevel().second = level; } + +private: + static std::pair<nostd::shared_ptr<LogHandler>, LogLevel> &GetHandlerAndLevel() noexcept; +}; + +} // namespace internal_log +} // namespace common +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE + +/** + * We can not decide the destroying order of signaltons. + * Which means, the destructors of other singletons (GlobalLogHandler,TracerProvider and etc.) + * may be called after destroying of global LogHandler and use OTEL_INTERNAL_LOG_* in it.We can do + * nothing but ignore the log in this situation. + */ +#define OTEL_INTERNAL_LOG_DISPATCH(level, message, attributes) \ + do \ + { \ + using opentelemetry::sdk::common::internal_log::GlobalLogHandler; \ + using opentelemetry::sdk::common::internal_log::LogHandler; \ + if (level > GlobalLogHandler::GetLogLevel()) \ + { \ + break; \ + } \ + const opentelemetry::nostd::shared_ptr<LogHandler> &log_handler = \ + GlobalLogHandler::GetLogHandler(); \ + if (!log_handler) \ + { \ + break; \ + } \ + std::stringstream tmp_stream; \ + tmp_stream << message; \ + log_handler->Handle(level, __FILE__, __LINE__, tmp_stream.str().c_str(), attributes); \ + } while (false); + +#define OTEL_INTERNAL_LOG_GET_3RD_ARG(arg1, arg2, arg3, ...) arg3 + +#if OTEL_INTERNAL_LOG_LEVEL >= OTEL_INTERNAL_LOG_LEVEL_ERROR +# define OTEL_INTERNAL_LOG_ERROR_1_ARGS(message) \ + OTEL_INTERNAL_LOG_DISPATCH(opentelemetry::sdk::common::internal_log::LogLevel::Error, message, \ + {}) +# define OTEL_INTERNAL_LOG_ERROR_2_ARGS(message, attributes) \ + OTEL_INTERNAL_LOG_DISPATCH(opentelemetry::sdk::common::internal_log::LogLevel::Error, message, \ + attributes) +# define OTEL_INTERNAL_LOG_ERROR_MACRO(...) \ + OTEL_INTERNAL_LOG_GET_3RD_ARG(__VA_ARGS__, OTEL_INTERNAL_LOG_ERROR_2_ARGS, \ + OTEL_INTERNAL_LOG_ERROR_1_ARGS) +# define OTEL_INTERNAL_LOG_ERROR(...) OTEL_INTERNAL_LOG_ERROR_MACRO(__VA_ARGS__)(__VA_ARGS__) +#else +# define OTEL_INTERNAL_LOG_ERROR(...) +#endif + +#if OTEL_INTERNAL_LOG_LEVEL >= OTEL_INTERNAL_LOG_LEVEL_WARN +# define OTEL_INTERNAL_LOG_WARN_1_ARGS(message) \ + OTEL_INTERNAL_LOG_DISPATCH(opentelemetry::sdk::common::internal_log::LogLevel::Warning, \ + message, {}) +# define OTEL_INTERNAL_LOG_WARN_2_ARGS(message, attributes) \ + OTEL_INTERNAL_LOG_DISPATCH(opentelemetry::sdk::common::internal_log::LogLevel::Warning, \ + message, attributes) +# define OTEL_INTERNAL_LOG_WARN_MACRO(...) \ + OTEL_INTERNAL_LOG_GET_3RD_ARG(__VA_ARGS__, OTEL_INTERNAL_LOG_WARN_2_ARGS, \ + OTEL_INTERNAL_LOG_WARN_1_ARGS) +# define OTEL_INTERNAL_LOG_WARN(...) OTEL_INTERNAL_LOG_WARN_MACRO(__VA_ARGS__)(__VA_ARGS__) +#else +# define OTEL_INTERNAL_LOG_ERROR(...) +#endif + +#if OTEL_INTERNAL_LOG_LEVEL >= OTEL_INTERNAL_LOG_LEVEL_DEBUG +# define OTEL_INTERNAL_LOG_DEBUG_1_ARGS(message) \ + OTEL_INTERNAL_LOG_DISPATCH(opentelemetry::sdk::common::internal_log::LogLevel::Debug, message, \ + {}) +# define OTEL_INTERNAL_LOG_DEBUG_2_ARGS(message, attributes) \ + OTEL_INTERNAL_LOG_DISPATCH(opentelemetry::sdk::common::internal_log::LogLevel::Debug, message, \ + attributes) +# define OTEL_INTERNAL_LOG_DEBUG_MACRO(...) \ + OTEL_INTERNAL_LOG_GET_3RD_ARG(__VA_ARGS__, OTEL_INTERNAL_LOG_DEBUG_2_ARGS, \ + OTEL_INTERNAL_LOG_DEBUG_1_ARGS) +# define OTEL_INTERNAL_LOG_DEBUG(...) OTEL_INTERNAL_LOG_DEBUG_MACRO(__VA_ARGS__)(__VA_ARGS__) +#else +# define OTEL_INTERNAL_LOG_DEBUG(...) +#endif + +#if OTEL_INTERNAL_LOG_LEVEL >= OTEL_INTERNAL_LOG_LEVEL_INFO +# define OTEL_INTERNAL_LOG_INFO_1_ARGS(message) \ + OTEL_INTERNAL_LOG_DISPATCH(opentelemetry::sdk::common::internal_log::LogLevel::Info, message, \ + {}) +# define OTEL_INTERNAL_LOG_INFO_2_ARGS(message, attributes) \ + OTEL_INTERNAL_LOG_DISPATCH(opentelemetry::sdk::common::internal_log::LogLevel::Info, message, \ + attributes) +# define OTEL_INTERNAL_LOG_INFO_MACRO(...) \ + OTEL_INTERNAL_LOG_GET_3RD_ARG(__VA_ARGS__, OTEL_INTERNAL_LOG_INFO_2_ARGS, \ + OTEL_INTERNAL_LOG_INFO_1_ARGS) +# define OTEL_INTERNAL_LOG_INFO(...) OTEL_INTERNAL_LOG_INFO_MACRO(__VA_ARGS__)(__VA_ARGS__) +#else +# define OTEL_INTERNAL_LOG_INFO(...) +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h new file mode 100644 index 000000000..20f82a5d1 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h @@ -0,0 +1,96 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/nostd/unique_ptr.h" +#include "opentelemetry/version.h" + +#include <functional> +#include <string> + +OPENTELEMETRY_BEGIN_NAMESPACE + +namespace sdk +{ +namespace instrumentationlibrary +{ + +class InstrumentationLibrary +{ +public: + InstrumentationLibrary(const InstrumentationLibrary &) = default; + + /** + * Returns a newly created InstrumentationLibrary with the specified library name and version. + * @param name name of the instrumentation library. + * @param version version of the instrumentation library. + * @param schema_url schema url of the telemetry emitted by the library. + * @returns the newly created InstrumentationLibrary. + */ + static nostd::unique_ptr<InstrumentationLibrary> Create(nostd::string_view name, + nostd::string_view version = "", + nostd::string_view schema_url = "") + { + return nostd::unique_ptr<InstrumentationLibrary>( + new InstrumentationLibrary{name, version, schema_url}); + } + + std::size_t HashCode() const noexcept { return hash_code_; } + + /** + * Compare 2 instrumentation libraries. + * @param other the instrumentation library to compare to. + * @returns true if the 2 instrumentation libraries are equal, false otherwise. + */ + bool operator==(const InstrumentationLibrary &other) const + { + return equal(other.name_, other.version_, other.schema_url_); + } + + /** + * Check whether the instrumentation library has given name and version. + * This could be used to check version equality and avoid heap allocation. + * @param name name of the instrumentation library to compare. + * @param version version of the instrumentatoin library to compare. + * @param schema_url schema url of the telemetry emitted by the library. + * @returns true if name and version in this instrumentation library are equal with the given name + * and version. + */ + bool equal(const nostd::string_view name, + const nostd::string_view version, + const nostd::string_view schema_url = "") const + { + return this->name_ == name && this->version_ == version && this->schema_url_ == schema_url; + } + + const std::string &GetName() const { return name_; } + const std::string &GetVersion() const { return version_; } + const std::string &GetSchemaURL() const { return schema_url_; } + +private: + InstrumentationLibrary(nostd::string_view name, + nostd::string_view version, + nostd::string_view schema_url = "") + : name_(name), version_(version), schema_url_(schema_url) + { + std::string hash_data; + hash_data.reserve(name_.size() + version_.size() + schema_url_.size()); + hash_data += name_; + hash_data += version_; + hash_data += schema_url_; + hash_code_ = std::hash<std::string>{}(hash_data); + } + +private: + std::string name_; + std::string version_; + std::string schema_url_; + std::size_t hash_code_; +}; + +} // namespace instrumentationlibrary +} // namespace sdk + +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/batch_log_processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/batch_log_processor.h new file mode 100644 index 000000000..1b6d443c8 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/batch_log_processor.h @@ -0,0 +1,128 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_LOGS_PREVIEW + +# include "opentelemetry/sdk/common/circular_buffer.h" +# include "opentelemetry/sdk/logs/exporter.h" +# include "opentelemetry/sdk/logs/processor.h" + +# include <atomic> +# include <condition_variable> +# include <thread> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ + +namespace logs +{ + +/** + * This is an implementation of the LogProcessor which creates batches of finished logs and passes + * the export-friendly log data representations to the configured LogExporter. + */ +class BatchLogProcessor : public LogProcessor +{ +public: + /** + * Creates a batch log processor by configuring the specified exporter and other parameters + * as per the official, language-agnostic opentelemetry specs. + * + * @param exporter - The backend exporter to pass the logs to + * @param max_queue_size - The maximum buffer/queue size. After the size is reached, logs are + * dropped. + * @param scheduled_delay_millis - The time interval between two consecutive exports. + * @param max_export_batch_size - The maximum batch size of every export. It must be smaller or + * equal to max_queue_size + */ + explicit BatchLogProcessor( + std::unique_ptr<LogExporter> &&exporter, + const size_t max_queue_size = 2048, + const std::chrono::milliseconds scheduled_delay_millis = std::chrono::milliseconds(5000), + const size_t max_export_batch_size = 512); + + /** Makes a new recordable **/ + std::unique_ptr<Recordable> MakeRecordable() noexcept override; + + /** + * Called when the Logger's log method creates a log record + * @param record the log record + */ + + void OnReceive(std::unique_ptr<Recordable> &&record) noexcept override; + + /** + * Export all log records that have not been exported yet. + * + * NOTE: Timeout functionality not supported yet. + */ + bool ForceFlush( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override; + + /** + * Shuts down the processor and does any cleanup required. Completely drains the buffer/queue of + * all its logs and passes them to the exporter. Any subsequent calls to + * ForceFlush or Shutdown will return immediately without doing anything. + * + * NOTE: Timeout functionality not supported yet. + */ + bool Shutdown( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override; + + /** + * Class destructor which invokes the Shutdown() method. + */ + virtual ~BatchLogProcessor() override; + +private: + /** + * The background routine performed by the worker thread. + */ + void DoBackgroundWork(); + + /** + * Exports all logs to the configured exporter. + * + * @param was_force_flush_called - A flag to check if the current export is the result + * of a call to ForceFlush method. If true, then we have to + * notify the main thread to wake it up in the ForceFlush + * method. + */ + void Export(const bool was_for_flush_called); + + /** + * Called when Shutdown() is invoked. Completely drains the queue of all log records and + * passes them to the exporter. + */ + void DrainQueue(); + + /* The configured backend log exporter */ + std::unique_ptr<LogExporter> exporter_; + + /* Configurable parameters as per the official *trace* specs */ + const size_t max_queue_size_; + const std::chrono::milliseconds scheduled_delay_millis_; + const size_t max_export_batch_size_; + + /* Synchronization primitives */ + std::condition_variable cv_, force_flush_cv_; + std::mutex cv_m_, force_flush_cv_m_, shutdown_m_; + + /* The buffer/queue to which the ended logs are added */ + common::CircularBuffer<Recordable> buffer_; + + /* Important boolean flags to handle the workflow of the processor */ + std::atomic<bool> is_shutdown_{false}; + std::atomic<bool> is_force_flush_{false}; + std::atomic<bool> is_force_flush_notified_{false}; + + /* The background worker thread */ + std::thread worker_thread_; +}; + +} // namespace logs +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/exporter.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/exporter.h new file mode 100644 index 000000000..85c58e9f1 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/exporter.h @@ -0,0 +1,62 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_LOGS_PREVIEW + +# include <memory> +# include <vector> +# include "opentelemetry/nostd/span.h" +# include "opentelemetry/sdk/common/exporter_utils.h" +# include "opentelemetry/sdk/logs/processor.h" +# include "opentelemetry/sdk/logs/recordable.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ +/** + * LogExporter defines the interface that log exporters must implement. + */ +class LogExporter +{ +public: + virtual ~LogExporter() = default; + + /** + * Create a log recordable. This object will be used to record log data and + * will subsequently be passed to LogExporter::Export. Vendors can implement + * custom recordables or use the default LogRecord recordable provided by the + * SDK. + * @return a newly initialized Recordable object + * + * Note: This method must be callable from multiple threads. + */ + virtual std::unique_ptr<Recordable> MakeRecordable() noexcept = 0; + + /** + * Exports the batch of log records to their export destination. + * This method must not be called concurrently for the same exporter instance. + * The exporter may attempt to retry sending the batch, but should drop + * and return kFailure after a certain timeout. + * @param records a span of unique pointers to log records + * @returns an ExportResult code (whether export was success or failure) + */ + virtual sdk::common::ExportResult Export( + const nostd::span<std::unique_ptr<Recordable>> &records) noexcept = 0; + + /** + * Marks the exporter as ShutDown and cleans up any resources as required. + * Shutdown should be called only once for each Exporter instance. + * @param timeout minimum amount of microseconds to wait for shutdown before giving up and + * returning failure. + * @return true if the exporter shutdown succeeded, false otherwise + */ + virtual bool Shutdown( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept = 0; +}; +} // namespace logs +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/log_record.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/log_record.h new file mode 100644 index 000000000..2a3a78289 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/log_record.h @@ -0,0 +1,193 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_LOGS_PREVIEW + +# include <map> +# include <unordered_map> +# include "opentelemetry/sdk/common/attribute_utils.h" +# include "opentelemetry/sdk/logs/recordable.h" +# include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ + +/** + * A default Recordable implemenation to be passed in log statements, + * matching the 10 fields of the Log Data Model. + * (https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#log-and-event-record-definition) + * + */ +class LogRecord final : public Recordable +{ +private: + // Default values are set by the respective data structures' constructors for all fields, + // except the severity field, which must be set manually (an enum with no default value). + opentelemetry::logs::Severity severity_ = opentelemetry::logs::Severity::kInvalid; + const opentelemetry::sdk::resource::Resource *resource_ = nullptr; + common::AttributeMap attributes_map_; + std::string body_; // Currently a simple string, but should be changed to "Any" type + opentelemetry::trace::TraceId trace_id_; + opentelemetry::trace::SpanId span_id_; + opentelemetry::trace::TraceFlags trace_flags_; + opentelemetry::common::SystemTimestamp timestamp_; // uint64 nanoseconds since Unix epoch + +public: + /********** Setters for each field (overrides methods from the Recordable interface) ************/ + + /** + * Set the severity for this log. + * @param severity the severity of the event + */ + void SetSeverity(opentelemetry::logs::Severity severity) noexcept override + { + severity_ = severity; + } + + /** + * Set body field for this log. + * @param message the body to set + */ + void SetBody(nostd::string_view message) noexcept override { body_ = std::string(message); } + + /** + * Set Resource of this log + * @param Resource the resource to set + */ + void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override + { + resource_ = &resource; + } + + /** + * Set an attribute of a log. + * @param name the name of the attribute + * @param value the attribute value + */ + + void SetAttribute(nostd::string_view key, + const opentelemetry::common::AttributeValue &value) noexcept override + { + attributes_map_.SetAttribute(key, value); + } + + /** + * Set trace id for this log. + * @param trace_id the trace id to set + */ + void SetTraceId(opentelemetry::trace::TraceId trace_id) noexcept override + { + trace_id_ = trace_id; + } + + /** + * Set span id for this log. + * @param span_id the span id to set + */ + virtual void SetSpanId(opentelemetry::trace::SpanId span_id) noexcept override + { + span_id_ = span_id; + } + + /** + * Inject a trace_flags for this log. + * @param trace_flags the span id to set + */ + void SetTraceFlags(opentelemetry::trace::TraceFlags trace_flags) noexcept override + { + trace_flags_ = trace_flags; + } + + /** + * Set the timestamp for this log. + * @param timestamp the timestamp of the event + */ + void SetTimestamp(opentelemetry::common::SystemTimestamp timestamp) noexcept override + { + timestamp_ = timestamp; + } + + /************************** Getters for each field ****************************/ + + /** + * Get the severity for this log + * @return the severity for this log + */ + opentelemetry::logs::Severity GetSeverity() const noexcept { return severity_; } + + /** + * Get the body of this log + * @return the body of this log + */ + std::string GetBody() const noexcept { return body_; } + + /** + * Get the resource for this log + * @return the resource for this log + */ + const opentelemetry::sdk::resource::Resource &GetResource() const noexcept + { + if (nullptr == resource_) + { + return sdk::resource::Resource::GetDefault(); + } + return *resource_; + } + + /** + * Get the attributes for this log + * @return the attributes for this log + */ + const std::unordered_map<std::string, common::OwnedAttributeValue> &GetAttributes() const noexcept + { + return attributes_map_.GetAttributes(); + } + + /** + * Get the trace id for this log + * @return the trace id for this log + */ + opentelemetry::trace::TraceId GetTraceId() const noexcept { return trace_id_; } + + /** + * Get the span id for this log + * @return the span id for this log + */ + opentelemetry::trace::SpanId GetSpanId() const noexcept { return span_id_; } + + /** + * Get the trace flags for this log + * @return the trace flags for this log + */ + opentelemetry::trace::TraceFlags GetTraceFlags() const noexcept { return trace_flags_; } + + /** + * Get the timestamp for this log + * @return the timestamp for this log + */ + opentelemetry::common::SystemTimestamp GetTimestamp() const noexcept { return timestamp_; } + + /** + * Set instrumentation_library for this log. + * @param instrumentation_library the instrumentation library to set + */ + void SetInstrumentationLibrary( + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary + &instrumentation_library) noexcept + { + instrumentation_library_ = &instrumentation_library; + } + +private: + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary + *instrumentation_library_ = nullptr; +}; +} // namespace logs +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/logger.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/logger.h new file mode 100644 index 000000000..4eeca2da1 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/logger.h @@ -0,0 +1,77 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_LOGS_PREVIEW + +# include "opentelemetry/logs/logger.h" +# include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h" +# include "opentelemetry/sdk/logs/logger_context.h" +# include "opentelemetry/sdk/logs/logger_provider.h" + +# include <vector> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ +class LoggerProvider; + +class Logger final : public opentelemetry::logs::Logger +{ +public: + /** + * Initialize a new logger. + * @param name The name of this logger instance + * @param context The logger provider that owns this logger. + */ + explicit Logger( + opentelemetry::nostd::string_view name, + std::shared_ptr<LoggerContext> context, + std::unique_ptr<instrumentationlibrary::InstrumentationLibrary> instrumentation_library = + instrumentationlibrary::InstrumentationLibrary::Create("")) noexcept; + + /** + * Returns the name of this logger. + */ + const opentelemetry::nostd::string_view GetName() noexcept override; + + /** + * Writes a log record into the processor. + * @param severity the severity level of the log event. + * @param message the string message of the log (perhaps support std::fmt or fmt-lib format). + * with the log event. + * @param attributes the attributes, stored as a 2D list of key/value pairs, that are associated + * with the log event. + * @param trace_id the trace id associated with the log event. + * @param span_id the span id associate with the log event. + * @param trace_flags the trace flags associated with the log event. + * @param timestamp the timestamp the log record was created. + * @throws No exceptions under any circumstances. */ + void Log(opentelemetry::logs::Severity severity, + nostd::string_view body, + const opentelemetry::common::KeyValueIterable &attributes, + opentelemetry::trace::TraceId trace_id, + opentelemetry::trace::SpanId span_id, + opentelemetry::trace::TraceFlags trace_flags, + opentelemetry::common::SystemTimestamp timestamp) noexcept override; + + /** Returns the associated instruementation library */ + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary & + GetInstrumentationLibrary() const noexcept; + +private: + // The name of this logger + std::string logger_name_; + + // order of declaration is important here - instrumentation library should destroy after + // logger-context. + std::unique_ptr<instrumentationlibrary::InstrumentationLibrary> instrumentation_library_; + std::shared_ptr<LoggerContext> context_; +}; + +} // namespace logs +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/logger_context.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/logger_context.h new file mode 100644 index 000000000..01c2f7dd8 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/logger_context.h @@ -0,0 +1,81 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#ifdef ENABLE_LOGS_PREVIEW + +# include "opentelemetry/sdk/logs/processor.h" +# include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ +/** + * A class which stores the LoggerContext context. + * + * This class meets the following design criteria: + * - A shared reference between LoggerProvider and Logger instantiated. + * - A thread-safe class that allows updating/altering processor/exporter pipelines + * and sampling config. + * - The owner/destroyer of Processors/Exporters. These will remain active until + * this class is destroyed. I.e. Sampling, Exporting, flushing, Custom Iterator etc. are all ok + * if this object is alive, and they will work together. If this object is destroyed, then no shared + * references to Processor, Exporter, Recordable, Custom Iterator etc. should exist, and all + * associated pipelines will have been flushed. + */ +class LoggerContext +{ +public: + explicit LoggerContext(std::vector<std::unique_ptr<LogProcessor>> &&processors, + opentelemetry::sdk::resource::Resource resource = + opentelemetry::sdk::resource::Resource::Create({})) noexcept; + + /** + * Attaches a log processor to list of configured processors to this tracer context. + * Processor once attached can't be removed. + * @param processor The new log processor for this tracer. This must not be + * a nullptr. Ownership is given to the `TracerContext`. + * + * Note: This method is not thread safe. + */ + void AddProcessor(std::unique_ptr<LogProcessor> processor) noexcept; + + /** + * Obtain the configured (composite) processor. + * + * Note: When more than one processor is active, this will + * return an "aggregate" processor + */ + LogProcessor &GetProcessor() const noexcept; + + /** + * Obtain the resource associated with this tracer context. + * @return The resource for this tracer context. + */ + const opentelemetry::sdk::resource::Resource &GetResource() const noexcept; + + /** + * Force all active LogProcessors to flush any buffered logs + * within the given timeout. + */ + bool ForceFlush(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept; + + /** + * Shutdown the log processor associated with this tracer provider. + */ + bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept; + +private: + // order of declaration is important here - resource object should be destroyed after processor. + opentelemetry::sdk::resource::Resource resource_; + std::unique_ptr<LogProcessor> processor_; +}; +} // namespace logs +} // namespace sdk + +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/logger_provider.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/logger_provider.h new file mode 100755 index 000000000..9afb67ba0 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/logger_provider.h @@ -0,0 +1,131 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0/ + +#pragma once +#ifdef ENABLE_LOGS_PREVIEW + +# include <memory> +# include <mutex> +# include <string> +# include <vector> + +# include "opentelemetry/logs/logger_provider.h" +# include "opentelemetry/logs/noop.h" +# include "opentelemetry/nostd/shared_ptr.h" +# include "opentelemetry/sdk/common/atomic_shared_ptr.h" +# include "opentelemetry/sdk/logs/logger.h" +# include "opentelemetry/sdk/logs/logger_context.h" +# include "opentelemetry/sdk/logs/processor.h" + +// Define the maximum number of loggers that are allowed to be registered to the loggerprovider. +// TODO: Add link to logging spec once this is added to it +# define MAX_LOGGER_COUNT 100 + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ +class Logger; + +class LoggerProvider final : public opentelemetry::logs::LoggerProvider +{ +public: + /** + * Initialize a new logger provider + * @param processor The span processor for this logger provider. This must + * not be a nullptr. + * @param resource The resources for this logger provider. + * @param sampler The sampler for this logger provider. This must + * not be a nullptr. + * @param id_generator The custom id generator for this logger provider. This must + * not be a nullptr + */ + explicit LoggerProvider(std::unique_ptr<LogProcessor> &&processor, + opentelemetry::sdk::resource::Resource resource = + opentelemetry::sdk::resource::Resource::Create({})) noexcept; + + explicit LoggerProvider(std::vector<std::unique_ptr<LogProcessor>> &&processors, + opentelemetry::sdk::resource::Resource resource = + opentelemetry::sdk::resource::Resource::Create({})) noexcept; + + /** + * Initialize a new logger provider. A processor must later be assigned + * to this logger provider via the AddProcessor() method. + */ + explicit LoggerProvider() noexcept; + + /** + * Initialize a new logger provider with a specified context + * @param context The shared logger configuration/pipeline for this provider. + */ + explicit LoggerProvider(std::shared_ptr<sdk::logs::LoggerContext> context) noexcept; + + ~LoggerProvider(); + + /** + * Creates a logger with the given name, and returns a shared pointer to it. + * If a logger with that name already exists, return a shared pointer to it + * @param logger_name The name of the logger to be created. + * @param options The options for the logger. TODO: Once the logging spec defines it, + * give a list of options that the logger supports. + * @param library_name The version of the library. + * @param library_version The version of the library. + * @param schema_url The schema URL. + */ + nostd::shared_ptr<opentelemetry::logs::Logger> GetLogger( + nostd::string_view logger_name, + nostd::string_view options, + nostd::string_view library_name, + nostd::string_view library_version = "", + nostd::string_view schema_url = "") noexcept override; + /** + * Creates a logger with the given name, and returns a shared pointer to it. + * If a logger with that name already exists, return a shared pointer to it + * @param name The name of the logger to be created. + * @param args The arguments for the logger. TODO: Once the logging spec defines it, + * give a list of arguments that the logger supports. + * @param library_name The version of the library. + * @param library_version The version of the library. + * @param schema_url The schema URL. + */ + nostd::shared_ptr<opentelemetry::logs::Logger> GetLogger( + nostd::string_view logger_name, + nostd::span<nostd::string_view> args, + nostd::string_view library_name, + nostd::string_view library_version = "", + nostd::string_view schema_url = "") noexcept override; + + /** + * Add the processor that is stored internally in the logger provider. + * @param processor The processor to be stored inside the logger provider. + * This must not be a nullptr. + */ + void AddProcessor(std::unique_ptr<LogProcessor> processor) noexcept; + + /** + * Obtain the resource associated with this logger provider. + * @return The resource for this logger provider. + */ + const opentelemetry::sdk::resource::Resource &GetResource() const noexcept; + + /** + * Shutdown the log processor associated with this log provider. + */ + bool Shutdown() noexcept; + + /** + * Force flush the log processor associated with this log provider. + */ + bool ForceFlush(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept; + +private: + // order of declaration is important here - loggers should destroy only after context. + std::vector<std::shared_ptr<opentelemetry::sdk::logs::Logger>> loggers_; + std::shared_ptr<sdk::logs::LoggerContext> context_; + std::mutex lock_; +}; +} // namespace logs +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/multi_log_processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/multi_log_processor.h new file mode 100644 index 000000000..c1bda24a0 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/multi_log_processor.h @@ -0,0 +1,69 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#ifdef ENABLE_LOGS_PREVIEW + +# include <memory> +# include <vector> + +# include "opentelemetry/sdk/logs/multi_recordable.h" +# include "opentelemetry/sdk/logs/processor.h" +# include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ + +/** + * Log processor allow hooks for receive method invocations. + * + * Built-in log processors are responsible for batching and conversion of + * logs to exportable representation and passing batches to exporters. + */ +class MultiLogProcessor : public LogProcessor +{ +public: + MultiLogProcessor(std::vector<std::unique_ptr<LogProcessor>> &&processors); + ~MultiLogProcessor(); + + void AddProcessor(std::unique_ptr<LogProcessor> &&processor); + + std::unique_ptr<Recordable> MakeRecordable() noexcept override; + + /** + * OnReceive is called by the SDK once a log record has been successfully created. + * @param record the log record + */ + void OnReceive(std::unique_ptr<Recordable> &&record) noexcept override; + + /** + * Exports all log records that have not yet been exported to the configured Exporter. + * @param timeout that the forceflush is required to finish within. + * @return a result code indicating whether it succeeded, failed or timed out + */ + bool ForceFlush( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override; + + /** + * Shuts down the processor and does any cleanup required. + * ShutDown should only be called once for each processor. + * @param timeout minimum amount of microseconds to wait for + * shutdown before giving up and returning failure. + * @return true if the shutdown succeeded, false otherwise + */ + bool Shutdown( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override; + +private: + std::vector<std::unique_ptr<LogProcessor>> processors_; +}; +} // namespace logs +} // namespace sdk + +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/multi_recordable.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/multi_recordable.h new file mode 100644 index 000000000..db3df9622 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/multi_recordable.h @@ -0,0 +1,104 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#ifdef ENABLE_LOGS_PREVIEW + +# include <cstddef> +# include <memory> +# include <unordered_map> + +# include "opentelemetry/sdk/logs/processor.h" +# include "opentelemetry/sdk/logs/recordable.h" +# include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ +class MultiRecordable final : public Recordable +{ +public: + void AddRecordable(const LogProcessor &processor, + std::unique_ptr<Recordable> recordable) noexcept; + + const std::unique_ptr<Recordable> &GetRecordable(const LogProcessor &processor) const noexcept; + + std::unique_ptr<Recordable> ReleaseRecordable(const LogProcessor &processor) noexcept; + + /** + * Set the timestamp for this log. + * @param timestamp the timestamp to set + */ + void SetTimestamp(opentelemetry::common::SystemTimestamp timestamp) noexcept override; + + /** + * Set the severity for this log. + * @param severity the severity of the event + */ + void SetSeverity(opentelemetry::logs::Severity severity) noexcept override; + + /** + * Set body field for this log. + * @param message the body to set + */ + void SetBody(nostd::string_view message) noexcept override; + + /** + * Set Resource of this log + * @param Resource the resource to set + */ + void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override; + + /** + * Set an attribute of a log. + * @param key the name of the attribute + * @param value the attribute value + */ + void SetAttribute(nostd::string_view key, + const opentelemetry::common::AttributeValue &value) noexcept override; + + /** + * Set the trace id for this log. + * @param trace_id the trace id to set + */ + void SetTraceId(opentelemetry::trace::TraceId trace_id) noexcept override; + + /** + * Set the span id for this log. + * @param span_id the span id to set + */ + void SetSpanId(opentelemetry::trace::SpanId span_id) noexcept override; + + /** + * Inject trace_flags for this log. + * @param trace_flags the trace flags to set + */ + void SetTraceFlags(opentelemetry::trace::TraceFlags trace_flags) noexcept override; + + /** + * Set instrumentation_library for this log. + * @param instrumentation_library the instrumentation library to set + */ + void SetInstrumentationLibrary( + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary + &instrumentation_library) noexcept override; + + /** Returns the associated instruementation library */ + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary & + GetInstrumentationLibrary() const noexcept; + +private: + std::unordered_map<std::size_t, std::unique_ptr<Recordable>> recordables_; + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary + *instrumentation_library_ = nullptr; +}; +} // namespace logs +} // namespace sdk + +OPENTELEMETRY_END_NAMESPACE + +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/processor.h new file mode 100644 index 000000000..36da036f3 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/processor.h @@ -0,0 +1,61 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_LOGS_PREVIEW + +# include <chrono> +# include <memory> +# include "opentelemetry/sdk/logs/recordable.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ +/** + * The Log Processor is responsible for passing log records + * to the configured exporter. + */ +class LogProcessor +{ +public: + virtual ~LogProcessor() = default; + + /** + * Create a log recordable. This requests a new log recordable from the + * associated exporter. + * @return a newly initialized recordable + * + * Note: This method must be callable from multiple threads. + */ + virtual std::unique_ptr<Recordable> MakeRecordable() noexcept = 0; + + /** + * OnReceive is called by the SDK once a log record has been successfully created. + * @param record the log record + */ + virtual void OnReceive(std::unique_ptr<Recordable> &&record) noexcept = 0; + + /** + * Exports all log records that have not yet been exported to the configured Exporter. + * @param timeout that the forceflush is required to finish within. + * @return a result code indicating whether it succeeded, failed or timed out + */ + virtual bool ForceFlush( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept = 0; + + /** + * Shuts down the processor and does any cleanup required. + * ShutDown should only be called once for each processor. + * @param timeout minimum amount of microseconds to wait for + * shutdown before giving up and returning failure. + * @return true if the shutdown succeeded, false otherwise + */ + virtual bool Shutdown( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept = 0; +}; +} // namespace logs +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/recordable.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/recordable.h new file mode 100644 index 000000000..4a3227373 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/recordable.h @@ -0,0 +1,97 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_LOGS_PREVIEW + +# include "opentelemetry/common/attribute_value.h" +# include "opentelemetry/common/key_value_iterable.h" +# include "opentelemetry/common/timestamp.h" +# include "opentelemetry/logs/severity.h" +# include "opentelemetry/sdk/common/empty_attributes.h" +# include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h" +# include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/trace/span.h" +# include "opentelemetry/trace/span_context.h" +# include "opentelemetry/trace/span_id.h" +# include "opentelemetry/trace/trace_flags.h" +# include "opentelemetry/trace/trace_id.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ +/** + * Maintains a representation of a log in a format that can be processed by a recorder. + * + * This class is thread-compatible. + */ +class Recordable +{ +public: + virtual ~Recordable() = default; + + /** + * Set the timestamp for this log. + * @param timestamp the timestamp to set + */ + virtual void SetTimestamp(opentelemetry::common::SystemTimestamp timestamp) noexcept = 0; + + /** + * Set the severity for this log. + * @param severity the severity of the event + */ + virtual void SetSeverity(opentelemetry::logs::Severity severity) noexcept = 0; + + /** + * Set body field for this log. + * @param message the body to set + */ + virtual void SetBody(nostd::string_view message) noexcept = 0; + + /** + * Set Resource of this log + * @param Resource the resource to set + */ + virtual void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept = 0; + + /** + * Set an attribute of a log. + * @param key the name of the attribute + * @param value the attribute value + */ + virtual void SetAttribute(nostd::string_view key, + const opentelemetry::common::AttributeValue &value) noexcept = 0; + + /** + * Set the trace id for this log. + * @param trace_id the trace id to set + */ + virtual void SetTraceId(opentelemetry::trace::TraceId trace_id) noexcept = 0; + + /** + * Set the span id for this log. + * @param span_id the span id to set + */ + virtual void SetSpanId(opentelemetry::trace::SpanId span_id) noexcept = 0; + + /** + * Inject trace_flags for this log. + * @param trace_flags the trace flags to set + */ + virtual void SetTraceFlags(opentelemetry::trace::TraceFlags trace_flags) noexcept = 0; + + /** + * Set instrumentation_library for this log. + * @param instrumentation_library the instrumentation library to set + */ + virtual void SetInstrumentationLibrary( + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary + &instrumentation_library) noexcept = 0; +}; +} // namespace logs +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/simple_log_processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/simple_log_processor.h new file mode 100644 index 000000000..cc3aec47b --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/logs/simple_log_processor.h @@ -0,0 +1,55 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifdef ENABLE_LOGS_PREVIEW + +# include <atomic> +# include <mutex> + +# include "opentelemetry/common/spin_lock_mutex.h" +# include "opentelemetry/sdk/logs/exporter.h" +# include "opentelemetry/sdk/logs/processor.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace logs +{ +/** + * The simple log processor passes all log records + * in a batch of 1 to the configured + * LogExporter. + * + * All calls to the configured LogExporter are synchronized using a + * spin-lock on an atomic_flag. + */ +class SimpleLogProcessor : public LogProcessor +{ + +public: + explicit SimpleLogProcessor(std::unique_ptr<LogExporter> &&exporter); + virtual ~SimpleLogProcessor() = default; + + std::unique_ptr<Recordable> MakeRecordable() noexcept override; + + void OnReceive(std::unique_ptr<Recordable> &&record) noexcept override; + + bool ForceFlush( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override; + + bool Shutdown( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override; + +private: + // The configured exporter + std::unique_ptr<LogExporter> exporter_; + // The lock used to ensure the exporter is not called concurrently + opentelemetry::common::SpinLockMutex lock_; + // The atomic boolean flag to ensure the ShutDown() function is only called once + std::atomic_flag shutdown_latch_ = ATOMIC_FLAG_INIT; +}; +} // namespace logs +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/aggregation.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/aggregation.h new file mode 100644 index 000000000..7ec9a6ea2 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/aggregation.h @@ -0,0 +1,55 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/nostd/string_view.h" +# include "opentelemetry/sdk/metrics/data/metric_data.h" +# include "opentelemetry/sdk/metrics/data/point_data.h" +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class Aggregation +{ +public: + virtual void Aggregate(long value, const PointAttributes &attributes = {}) noexcept = 0; + + virtual void Aggregate(double value, const PointAttributes &attributes = {}) noexcept = 0; + + /** + * Returns the result of the merge of the two aggregations. + * + * This should always assume that the aggregations do not overlap and merge together for a new + * cumulative report. + * + * @param delta the newly captured (delta) aggregation + * @return the result of the merge of the given aggregation. + */ + + virtual std::unique_ptr<Aggregation> Merge(const Aggregation &delta) const noexcept = 0; + + /** + * Returns a new delta aggregation by comparing two cumulative measurements. + * + * @param next the newly captured (cumulative) aggregation. + * @return The resulting delta aggregation. + */ + virtual std::unique_ptr<Aggregation> Diff(const Aggregation &next) const noexcept = 0; + + /** + * Returns the point data that the aggregation will produce. + * + * @return PointType + */ + + virtual PointType ToPoint() const noexcept = 0; + + virtual ~Aggregation() = default; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/default_aggregation.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/default_aggregation.h new file mode 100644 index 000000000..887e1beb9 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/default_aggregation.h @@ -0,0 +1,146 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/spin_lock_mutex.h" +# include "opentelemetry/sdk/metrics/aggregation/aggregation.h" +# include "opentelemetry/sdk/metrics/aggregation/drop_aggregation.h" +# include "opentelemetry/sdk/metrics/aggregation/histogram_aggregation.h" +# include "opentelemetry/sdk/metrics/aggregation/lastvalue_aggregation.h" +# include "opentelemetry/sdk/metrics/aggregation/sum_aggregation.h" +# include "opentelemetry/sdk/metrics/instruments.h" + +# include <mutex> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class DefaultAggregation +{ +public: + static std::unique_ptr<Aggregation> CreateAggregation( + const opentelemetry::sdk::metrics::InstrumentDescriptor &instrument_descriptor) + { + switch (instrument_descriptor.type_) + { + case InstrumentType::kCounter: + case InstrumentType::kUpDownCounter: + case InstrumentType::kObservableCounter: + case InstrumentType::kObservableUpDownCounter: + return (instrument_descriptor.value_type_ == InstrumentValueType::kLong) + ? std::move(std::unique_ptr<Aggregation>(new LongSumAggregation())) + : std::move(std::unique_ptr<Aggregation>(new DoubleSumAggregation())); + break; + case InstrumentType::kHistogram: + return (instrument_descriptor.value_type_ == InstrumentValueType::kLong) + ? std::move(std::unique_ptr<Aggregation>(new LongHistogramAggregation())) + : std::move(std::unique_ptr<Aggregation>(new DoubleHistogramAggregation())); + break; + case InstrumentType::kObservableGauge: + return (instrument_descriptor.value_type_ == InstrumentValueType::kLong) + ? std::move(std::unique_ptr<Aggregation>(new LongLastValueAggregation())) + : std::move(std::unique_ptr<Aggregation>(new DoubleLastValueAggregation())); + break; + default: + return std::move(std::unique_ptr<Aggregation>(new DropAggregation())); + }; + } + + static std::unique_ptr<Aggregation> CreateAggregation(AggregationType aggregation_type, + InstrumentDescriptor instrument_descriptor) + { + switch (aggregation_type) + { + case AggregationType::kDrop: + return std::unique_ptr<Aggregation>(new DropAggregation()); + break; + case AggregationType::kHistogram: + if (instrument_descriptor.value_type_ == InstrumentValueType::kLong) + { + return std::unique_ptr<Aggregation>(new LongHistogramAggregation()); + } + else + { + return std::unique_ptr<Aggregation>(new DoubleHistogramAggregation()); + } + break; + case AggregationType::kLastValue: + if (instrument_descriptor.value_type_ == InstrumentValueType::kLong) + { + return std::unique_ptr<Aggregation>(new LongLastValueAggregation()); + } + else + { + return std::unique_ptr<Aggregation>(new DoubleLastValueAggregation()); + } + break; + case AggregationType::kSum: + if (instrument_descriptor.value_type_ == InstrumentValueType::kLong) + { + return std::unique_ptr<Aggregation>(new LongSumAggregation()); + } + else + { + return std::unique_ptr<Aggregation>(new DoubleSumAggregation()); + } + break; + default: + return DefaultAggregation::CreateAggregation(instrument_descriptor); + } + } + + static std::unique_ptr<Aggregation> CloneAggregation(AggregationType aggregation_type, + InstrumentDescriptor instrument_descriptor, + const Aggregation &to_copy) + { + const PointType point_data = to_copy.ToPoint(); + switch (aggregation_type) + { + case AggregationType::kDrop: + return std::unique_ptr<Aggregation>(new DropAggregation()); + case AggregationType::kHistogram: + if (instrument_descriptor.value_type_ == InstrumentValueType::kLong) + { + return std::unique_ptr<Aggregation>( + new LongHistogramAggregation(nostd::get<HistogramPointData>(point_data))); + } + else + { + return std::unique_ptr<Aggregation>( + new DoubleHistogramAggregation(nostd::get<HistogramPointData>(point_data))); + } + case AggregationType::kLastValue: + if (instrument_descriptor.value_type_ == InstrumentValueType::kLong) + { + return std::unique_ptr<Aggregation>( + new LongLastValueAggregation(nostd::get<LastValuePointData>(point_data))); + } + else + { + return std::unique_ptr<Aggregation>( + new DoubleLastValueAggregation(nostd::get<LastValuePointData>(point_data))); + } + case AggregationType::kSum: + if (instrument_descriptor.value_type_ == InstrumentValueType::kLong) + { + return std::unique_ptr<Aggregation>( + new LongSumAggregation(nostd::get<SumPointData>(point_data))); + } + else + { + return std::unique_ptr<Aggregation>( + new DoubleSumAggregation(nostd::get<SumPointData>(point_data))); + } + default: + return DefaultAggregation::CreateAggregation(instrument_descriptor); + } + } +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/drop_aggregation.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/drop_aggregation.h new file mode 100644 index 000000000..6c3d89d24 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/drop_aggregation.h @@ -0,0 +1,51 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/spin_lock_mutex.h" +# include "opentelemetry/sdk/metrics/aggregation/aggregation.h" + +# include <mutex> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +/** + * A null Aggregation which denotes no aggregation should occur. + */ + +class DropAggregation : public Aggregation +{ +public: + DropAggregation() = default; + + DropAggregation(const DropPointData &) {} + + void Aggregate(long value, const PointAttributes &attributes = {}) noexcept override {} + + void Aggregate(double value, const PointAttributes &attributes = {}) noexcept override {} + + std::unique_ptr<Aggregation> Merge(const Aggregation &) const noexcept override + { + return std::unique_ptr<Aggregation>(new DropAggregation()); + } + + std::unique_ptr<Aggregation> Diff(const Aggregation &) const noexcept override + { + return std::unique_ptr<Aggregation>(new DropAggregation()); + } + + PointType ToPoint() const noexcept override + { + static DropPointData point_data; + return point_data; + } +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/histogram_aggregation.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/histogram_aggregation.h new file mode 100644 index 000000000..e2a55fba5 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/histogram_aggregation.h @@ -0,0 +1,103 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/spin_lock_mutex.h" +# include "opentelemetry/sdk/metrics/aggregation/aggregation.h" + +# include <mutex> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class LongHistogramAggregation : public Aggregation +{ +public: + LongHistogramAggregation(); + LongHistogramAggregation(HistogramPointData &&); + LongHistogramAggregation(const HistogramPointData &); + + void Aggregate(long value, const PointAttributes &attributes = {}) noexcept override; + + void Aggregate(double value, const PointAttributes &attributes = {}) noexcept override {} + + /* Returns the result of merge of the existing aggregation with delta aggregation with same + * boundaries */ + std::unique_ptr<Aggregation> Merge(const Aggregation &delta) const noexcept override; + + /* Returns the new delta aggregation by comparing existing aggregation with next aggregation with + * same boundaries. Data points for `next` aggregation (sum , bucket-counts) should be more than + * the current aggregation - which is the normal scenario as measurements values are monotonic + * increasing. + */ + std::unique_ptr<Aggregation> Diff(const Aggregation &next) const noexcept override; + + PointType ToPoint() const noexcept override; + +private: + opentelemetry::common::SpinLockMutex lock_; + HistogramPointData point_data_; +}; + +class DoubleHistogramAggregation : public Aggregation +{ +public: + DoubleHistogramAggregation(); + DoubleHistogramAggregation(HistogramPointData &&); + DoubleHistogramAggregation(const HistogramPointData &); + + void Aggregate(long value, const PointAttributes &attributes = {}) noexcept override {} + + void Aggregate(double value, const PointAttributes &attributes = {}) noexcept override; + + /* Returns the result of merge of the existing aggregation with delta aggregation with same + * boundaries */ + std::unique_ptr<Aggregation> Merge(const Aggregation &delta) const noexcept override; + + /* Returns the new delta aggregation by comparing existing aggregation with next aggregation with + * same boundaries. Data points for `next` aggregation (sum , bucket-counts) should be more than + * the current aggregation - which is the normal scenario as measurements values are monotonic + * increasing. + */ + std::unique_ptr<Aggregation> Diff(const Aggregation &next) const noexcept override; + + PointType ToPoint() const noexcept override; + +private: + mutable opentelemetry::common::SpinLockMutex lock_; + mutable HistogramPointData point_data_; +}; + +template <class T> +void HistogramMerge(HistogramPointData ¤t, + HistogramPointData &delta, + HistogramPointData &merge) +{ + for (size_t i = 0; i < current.counts_.size(); i++) + { + merge.counts_[i] = current.counts_[i] + delta.counts_[i]; + } + merge.boundaries_ = current.boundaries_; + merge.sum_ = nostd::get<T>(current.sum_) + nostd::get<T>(delta.sum_); + merge.count_ = current.count_ + delta.count_; +} + +template <class T> +void HistogramDiff(HistogramPointData ¤t, HistogramPointData &next, HistogramPointData &diff) +{ + for (size_t i = 0; i < current.counts_.size(); i++) + { + diff.counts_[i] = next.counts_[i] - current.counts_[i]; + } + diff.boundaries_ = current.boundaries_; + diff.count_ = next.count_ - current.count_; +} + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/lastvalue_aggregation.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/lastvalue_aggregation.h new file mode 100644 index 000000000..3b2c08f8c --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/lastvalue_aggregation.h @@ -0,0 +1,63 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/spin_lock_mutex.h" +# include "opentelemetry/sdk/metrics/aggregation/aggregation.h" + +# include <mutex> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class LongLastValueAggregation : public Aggregation +{ +public: + LongLastValueAggregation(); + LongLastValueAggregation(LastValuePointData &&); + LongLastValueAggregation(const LastValuePointData &); + + void Aggregate(long value, const PointAttributes &attributes = {}) noexcept override; + + void Aggregate(double value, const PointAttributes &attributes = {}) noexcept override {} + + std::unique_ptr<Aggregation> Merge(const Aggregation &delta) const noexcept override; + + std::unique_ptr<Aggregation> Diff(const Aggregation &next) const noexcept override; + + PointType ToPoint() const noexcept override; + +private: + opentelemetry::common::SpinLockMutex lock_; + LastValuePointData point_data_; +}; + +class DoubleLastValueAggregation : public Aggregation +{ +public: + DoubleLastValueAggregation(); + DoubleLastValueAggregation(LastValuePointData &&); + DoubleLastValueAggregation(const LastValuePointData &); + + void Aggregate(long value, const PointAttributes &attributes = {}) noexcept override {} + + void Aggregate(double value, const PointAttributes &attributes = {}) noexcept override; + + virtual std::unique_ptr<Aggregation> Merge(const Aggregation &delta) const noexcept override; + + virtual std::unique_ptr<Aggregation> Diff(const Aggregation &next) const noexcept override; + + PointType ToPoint() const noexcept override; + +private: + mutable opentelemetry::common::SpinLockMutex lock_; + mutable LastValuePointData point_data_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/sum_aggregation.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/sum_aggregation.h new file mode 100644 index 000000000..14f13bd72 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/aggregation/sum_aggregation.h @@ -0,0 +1,64 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/spin_lock_mutex.h" +# include "opentelemetry/sdk/metrics/aggregation/aggregation.h" + +# include <mutex> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class LongSumAggregation : public Aggregation +{ +public: + LongSumAggregation(); + LongSumAggregation(SumPointData &&); + LongSumAggregation(const SumPointData &); + + void Aggregate(long value, const PointAttributes &attributes = {}) noexcept override; + + void Aggregate(double value, const PointAttributes &attributes = {}) noexcept override {} + + std::unique_ptr<Aggregation> Merge(const Aggregation &delta) const noexcept override; + + std::unique_ptr<Aggregation> Diff(const Aggregation &next) const noexcept override; + + PointType ToPoint() const noexcept override; + +private: + opentelemetry::common::SpinLockMutex lock_; + SumPointData point_data_; +}; + +class DoubleSumAggregation : public Aggregation +{ +public: + DoubleSumAggregation(); + DoubleSumAggregation(SumPointData &&); + DoubleSumAggregation(const SumPointData &); + + void Aggregate(long value, const PointAttributes &attributes = {}) noexcept override {} + + void Aggregate(double value, const PointAttributes &attributes = {}) noexcept override; + + std::unique_ptr<Aggregation> Merge(const Aggregation &delta) const noexcept override; + + std::unique_ptr<Aggregation> Diff(const Aggregation &next) const noexcept override; + + PointType ToPoint() const noexcept override; + +private: + mutable opentelemetry::common::SpinLockMutex lock_; + SumPointData point_data_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/async_instruments.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/async_instruments.h new file mode 100644 index 000000000..8b1f76377 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/async_instruments.h @@ -0,0 +1,115 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/metrics/async_instruments.h" +# include "opentelemetry/metrics/observer_result.h" +# include "opentelemetry/nostd/string_view.h" +# include "opentelemetry/sdk/metrics/instruments.h" +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +template <class T> +class Asynchronous +{ +public: + Asynchronous(nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<T> &), + nostd::string_view description = "", + nostd::string_view unit = "") + : name_(name), callback_(callback), description_(description), unit_(unit) + {} + +protected: + std::string name_; + void (*callback_)(opentelemetry::metrics::ObserverResult<T> &); + std::string description_; + std::string unit_; +}; + +class LongObservableCounter : public opentelemetry::metrics::ObservableCounter<long>, + public Asynchronous<long> +{ +public: + LongObservableCounter(nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<long> &), + nostd::string_view description = "", + nostd::string_view unit = "") + : Asynchronous(name, callback, description, unit) + + {} +}; + +class DoubleObservableCounter : public opentelemetry::metrics::ObservableCounter<double>, + public Asynchronous<double> +{ +public: + DoubleObservableCounter(nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<double> &), + nostd::string_view description = "", + nostd::string_view unit = "") + : Asynchronous(name, callback, description, unit) + + {} +}; + +class LongObservableGauge : public opentelemetry::metrics::ObservableGauge<long>, + public Asynchronous<long> +{ +public: + LongObservableGauge(nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<long> &), + nostd::string_view description = "", + nostd::string_view unit = "") + : Asynchronous(name, callback, description, unit) + + {} +}; + +class DoubleObservableGauge : public opentelemetry::metrics::ObservableGauge<double>, + public Asynchronous<double> +{ +public: + DoubleObservableGauge(nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<double> &), + nostd::string_view description = "", + nostd::string_view unit = "") + : Asynchronous(name, callback, description, unit) + + {} +}; + +class LongObservableUpDownCounter : public opentelemetry::metrics::ObservableUpDownCounter<long>, + public Asynchronous<long> +{ +public: + LongObservableUpDownCounter(nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<long> &), + nostd::string_view description = "", + nostd::string_view unit = "") + : Asynchronous(name, callback, description, unit) + + {} +}; + +class DoubleObservableUpDownCounter + : public opentelemetry::metrics::ObservableUpDownCounter<double>, + public Asynchronous<double> +{ +public: + DoubleObservableUpDownCounter(nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<double> &), + nostd::string_view description = "", + nostd::string_view unit = "") + : Asynchronous(name, callback, description, unit) + {} +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/data/metric_data.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/data/metric_data.h new file mode 100644 index 000000000..738d4540f --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/data/metric_data.h @@ -0,0 +1,42 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/nostd/variant.h" +# include "opentelemetry/sdk/common/attribute_utils.h" +# include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h" +# include "opentelemetry/sdk/metrics/data/point_data.h" +# include "opentelemetry/sdk/metrics/instruments.h" +# include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +using PointAttributes = opentelemetry::sdk::common::OrderedAttributeMap; +using PointType = opentelemetry::nostd:: + variant<SumPointData, HistogramPointData, LastValuePointData, DropPointData>; + +struct PointDataAttributes +{ + PointAttributes attributes; + PointType point_data; +}; + +class MetricData +{ +public: + InstrumentDescriptor instrument_descriptor; + opentelemetry::common::SystemTimestamp start_ts; + opentelemetry::common::SystemTimestamp end_ts; + std::vector<PointDataAttributes> point_data_attr_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/data/point_data.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/data/point_data.h new file mode 100644 index 000000000..714f96c9a --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/data/point_data.h @@ -0,0 +1,78 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/timestamp.h" +# include "opentelemetry/nostd/variant.h" +# include "opentelemetry/sdk/metrics/instruments.h" +# include "opentelemetry/version.h" + +# include <list> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +using ValueType = nostd::variant<long, double>; +using ListType = nostd::variant<std::list<long>, std::list<double>>; + +// TODO: remove ctors and initializers from below classes when GCC<5 stops shipping on Ubuntu + +class SumPointData +{ +public: + // TODO: remove ctors and initializers when GCC<5 stops shipping on Ubuntu + SumPointData(SumPointData &&) = default; + SumPointData(const SumPointData &) = default; + SumPointData &operator=(SumPointData &&) = default; + SumPointData() = default; + + ValueType value_ = {}; +}; + +class LastValuePointData +{ +public: + // TODO: remove ctors and initializers when GCC<5 stops shipping on Ubuntu + LastValuePointData(LastValuePointData &&) = default; + LastValuePointData(const LastValuePointData &) = default; + LastValuePointData &operator=(LastValuePointData &&) = default; + LastValuePointData() = default; + + ValueType value_ = {}; + bool is_lastvalue_valid_ = {}; + opentelemetry::common::SystemTimestamp sample_ts_ = {}; +}; + +class HistogramPointData +{ +public: + // TODO: remove ctors and initializers when GCC<5 stops shipping on Ubuntu + HistogramPointData(HistogramPointData &&) = default; + HistogramPointData &operator=(HistogramPointData &&) = default; + HistogramPointData(const HistogramPointData &) = default; + HistogramPointData() = default; + + ListType boundaries_ = {}; + ValueType sum_ = {}; + std::vector<uint64_t> counts_ = {}; + uint64_t count_ = {}; +}; + +class DropPointData +{ +public: + // TODO: remove ctors and initializers when GCC<5 stops shipping on Ubuntu + DropPointData(DropPointData &&) = default; + DropPointData(const DropPointData &) = default; + DropPointData() = default; + DropPointData &operator=(DropPointData &&) = default; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/always_sample_filter.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/always_sample_filter.h new file mode 100644 index 000000000..5e7f0436e --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/always_sample_filter.h @@ -0,0 +1,43 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/sdk/metrics/exemplar/filter.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class AlwaysSampleFilter final : public ExemplarFilter +{ +public: + static nostd::shared_ptr<ExemplarFilter> GetAlwaysSampleFilter() + { + static nostd::shared_ptr<ExemplarFilter> alwaysSampleFilter{new AlwaysSampleFilter{}}; + return alwaysSampleFilter; + } + + bool ShouldSampleMeasurement(long value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context) noexcept override + { + return true; + } + + bool ShouldSampleMeasurement(double value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context) noexcept override + { + return true; + } + +private: + explicit AlwaysSampleFilter() = default; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/data.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/data.h new file mode 100644 index 000000000..14eac6249 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/data.h @@ -0,0 +1,45 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/timestamp.h" +# include "opentelemetry/context/context.h" +# include "opentelemetry/sdk/common/attribute_utils.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +using MetricAttributes = opentelemetry::sdk::common::OrderedAttributeMap; +/** + * A sample input measurement. + * + * Exemplars also hold information about the environment when the measurement was recorded, for + * example the span and trace ID of the active span when the exemplar was recorded. + */ +class ExemplarData +{ +public: + /** + * The set of key/value pairs that were filtered out by the aggregator, but recorded alongside the + * original measurement. Only key/value pairs that were filtered out by the aggregator should be + * included + */ + MetricAttributes GetFilteredAttributes(); + + /** Returns the timestamp in nanos when measurement was collected. */ + opentelemetry::common::SystemTimestamp GetEpochNanos(); + + /** + * Returns the SpanContext associated with this exemplar. If the exemplar was not recorded + * inside a sampled trace, the Context will be invalid. + */ + opentelemetry::context::Context GetSpanContext(); +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/filter.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/filter.h new file mode 100644 index 000000000..4b512e131 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/filter.h @@ -0,0 +1,39 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/context/context.h" +# include "opentelemetry/sdk/common/attribute_utils.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +using MetricAttributes = opentelemetry::sdk::common::OrderedAttributeMap; + +/** + * Exemplar filters are used to pre-filter measurements before attempting to store them in a + * reservoir. + */ +class ExemplarFilter +{ +public: + // Returns whether or not a reservoir should attempt to filter a measurement. + virtual bool ShouldSampleMeasurement(long value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context) noexcept = 0; + + // Returns whether or not a reservoir should attempt to filter a measurement. + virtual bool ShouldSampleMeasurement(double value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context) noexcept = 0; + + virtual ~ExemplarFilter() = default; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/never_sample_filter.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/never_sample_filter.h new file mode 100644 index 000000000..38f51778c --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/never_sample_filter.h @@ -0,0 +1,43 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/sdk/metrics/exemplar/filter.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class NeverSampleFilter final : public ExemplarFilter +{ +public: + static nostd::shared_ptr<ExemplarFilter> GetNeverSampleFilter() + { + nostd::shared_ptr<ExemplarFilter> neverSampleFilter{new NeverSampleFilter{}}; + return neverSampleFilter; + } + + bool ShouldSampleMeasurement(long value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context) noexcept override + { + return false; + } + + bool ShouldSampleMeasurement(double value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context) noexcept override + { + return false; + } + +private: + explicit NeverSampleFilter() = default; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/no_exemplar_reservoir.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/no_exemplar_reservoir.h new file mode 100644 index 000000000..1fe0586d2 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/no_exemplar_reservoir.h @@ -0,0 +1,55 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include <vector> +# include "opentelemetry/context/context.h" +# include "opentelemetry/nostd/shared_ptr.h" +# include "opentelemetry/sdk/common/attribute_utils.h" +# include "opentelemetry/sdk/metrics/exemplar/reservoir.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class NoExemplarReservoir final : public ExemplarReservoir +{ + +public: + static nostd::shared_ptr<ExemplarReservoir> GetNoExemplarReservoir() + { + return nostd::shared_ptr<ExemplarReservoir>{new NoExemplarReservoir{}}; + } + + void OfferMeasurement(long value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context, + const opentelemetry::common::SystemTimestamp ×tamp) noexcept override + { + // Stores nothing + } + + void OfferMeasurement(double value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context, + const opentelemetry::common::SystemTimestamp ×tamp) noexcept override + { + // Stores nothing. + } + + std::vector<ExemplarData> CollectAndReset( + const MetricAttributes &pointAttributes) noexcept override + { + return std::vector<ExemplarData>{}; + } + +private: + explicit NoExemplarReservoir() = default; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/reservoir.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/reservoir.h new file mode 100644 index 000000000..25e8421d6 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/exemplar/reservoir.h @@ -0,0 +1,55 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include <vector> +# include "opentelemetry/sdk/metrics/exemplar/data.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +/** + * An interface for an exemplar reservoir of samples. + * + * <p>This represents a reservoir for a specific "point" of metric data. + */ +class ExemplarReservoir +{ +public: + virtual ~ExemplarReservoir() = default; + + /** Offers a long measurement to be sampled. */ + virtual void OfferMeasurement( + long value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context, + const opentelemetry::common::SystemTimestamp ×tamp) noexcept = 0; + + /** Offers a double measurement to be sampled. */ + virtual void OfferMeasurement( + double value, + const MetricAttributes &attributes, + const opentelemetry::context::Context &context, + const opentelemetry::common::SystemTimestamp ×tamp) noexcept = 0; + + /** + * Builds vector of Exemplars for exporting from the current reservoir. + * + * <p>Additionally, clears the reservoir for the next sampling period. + * + * @param pointAttributes the Attributes associated with the metric point. + * ExemplarDatas should filter these out of their final data state. + * @return A vector of sampled exemplars for this point. Implementers are expected to + * filter out pointAttributes from the original recorded attributes. + */ + virtual std::vector<ExemplarData> CollectAndReset( + const MetricAttributes &pointAttributes) noexcept = 0; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/export/metric_producer.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/export/metric_producer.h new file mode 100644 index 000000000..d3b38759a --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/export/metric_producer.h @@ -0,0 +1,57 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h" +# include "opentelemetry/sdk/metrics/data/metric_data.h" +# include "opentelemetry/sdk/resource/resource.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +/** + * Metric Data to be exported along with resources and + * Instrumentation library. + */ +struct InstrumentationInfoMetrics +{ + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary + *instrumentation_library_; + std::vector<MetricData> metric_data_; +}; + +struct ResourceMetrics +{ + const opentelemetry::sdk::resource::Resource *resource_; + std::vector<InstrumentationInfoMetrics> instrumentation_info_metric_data_; +}; + +/** + * MetricProducer is the interface that is used to make metric data available to the + * OpenTelemetry exporters. Implementations should be stateful, in that each call to + * `Collect` will return any metric generated since the last call was made. + * + * <p>Implementations must be thread-safe. + */ + +class MetricProducer +{ +public: + /** + * The callback to be called for each metric exporter. This will only be those + * metrics that have been produced since the last time this method was called. + * + * @return a status of completion of method. + */ + virtual bool Collect( + nostd::function_ref<bool(ResourceMetrics &metric_data)> callback) noexcept = 0; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader.h new file mode 100644 index 000000000..29125a6ea --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader.h @@ -0,0 +1,72 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW + +# include "opentelemetry/sdk/metrics/metric_reader.h" +# include "opentelemetry/version.h" + +# include <atomic> +# include <chrono> +# include <condition_variable> +# include <thread> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class MetricExporter; +/** + * Struct to hold PeriodicExortingMetricReader options. + */ + +constexpr std::chrono::milliseconds kExportIntervalMillis = std::chrono::milliseconds(60000); +constexpr std::chrono::milliseconds kExportTimeOutMillis = std::chrono::milliseconds(30000); +struct PeriodicExportingMetricReaderOptions +{ + + /* The time interval between two consecutive exports. */ + std::chrono::milliseconds export_interval_millis = + std::chrono::milliseconds(kExportIntervalMillis); + + /* how long the export can run before it is cancelled. */ + std::chrono::milliseconds export_timeout_millis = std::chrono::milliseconds(kExportTimeOutMillis); +}; + +class PeriodicExportingMetricReader : public MetricReader +{ + +public: + PeriodicExportingMetricReader( + std::unique_ptr<MetricExporter> exporter, + const PeriodicExportingMetricReaderOptions &option, + AggregationTemporality aggregation_temporality = AggregationTemporality::kCumulative); + +private: + bool OnForceFlush(std::chrono::microseconds timeout) noexcept override; + + bool OnShutDown(std::chrono::microseconds timeout) noexcept override; + + void OnInitialized() noexcept override; + + std::unique_ptr<MetricExporter> exporter_; + std::chrono::milliseconds export_interval_millis_; + std::chrono::milliseconds export_timeout_millis_; + + void DoBackgroundWork(); + + /* The background worker thread */ + std::thread worker_thread_; + + /* Synchronization primitives */ + std::condition_variable cv_; + std::mutex cv_m_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/instruments.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/instruments.h new file mode 100644 index 000000000..5d8535714 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/instruments.h @@ -0,0 +1,70 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/sdk/common/attribute_utils.h" +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +enum class InstrumentType +{ + kCounter, + kHistogram, + kUpDownCounter, + kObservableCounter, + kObservableGauge, + kObservableUpDownCounter +}; + +enum class InstrumentValueType +{ + kInt, + kLong, + kFloat, + kDouble +}; + +enum class AggregationType +{ + kDrop, + kHistogram, + kLastValue, + kSum, + kDefault +}; + +enum class AggregationTemporality +{ + kUnspecified, + kDelta, + kCumulative +}; + +struct InstrumentDescriptor +{ + std::string name_; + std::string description_; + std::string unit_; + InstrumentType type_; + InstrumentValueType value_type_; +}; + +using MetricAttributes = opentelemetry::sdk::common::OrderedAttributeMap; + +/*class InstrumentSelector { +public: +InstrumentSelector(opentelemetry::nostd::string_view name, +opentelemetry::sdk::metrics::InstrumentType type): name_(name.data()), type_(type) {} InstrumentType +GetType(){return type_;} std::string GetNameFilter() { return name_;} + +private: +std::string name_; +InstrumentType type_; +};*/ +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/meter.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/meter.h new file mode 100644 index 000000000..44e54adf1 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/meter.h @@ -0,0 +1,156 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include <chrono> +# include "opentelemetry/metrics/meter.h" +# include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h" +# include "opentelemetry/sdk/metrics/instruments.h" +# include "opentelemetry/sdk/metrics/meter_context.h" +# include "opentelemetry/sdk/metrics/state/async_metric_storage.h" + +# include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class MetricStorage; +class WritableMetricStorage; + +class Meter final : public opentelemetry::metrics::Meter +{ +public: + /** Construct a new Meter with the given pipeline. */ + explicit Meter(std::shared_ptr<sdk::metrics::MeterContext> meter_context, + std::unique_ptr<opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary> + instrumentation_library = + opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary::Create( + "")) noexcept; + + nostd::shared_ptr<opentelemetry::metrics::Counter<long>> CreateLongCounter( + nostd::string_view name, + nostd::string_view description = "", + nostd::string_view unit = "") noexcept override; + + nostd::shared_ptr<opentelemetry::metrics::Counter<double>> CreateDoubleCounter( + nostd::string_view name, + nostd::string_view description = "", + nostd::string_view unit = "") noexcept override; + + void CreateLongObservableCounter(nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<long> &, + void *), + nostd::string_view description = "", + nostd::string_view unit = "", + void *state = nullptr) noexcept override; + + void CreateDoubleObservableCounter( + nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<double> &, void *), + nostd::string_view description = "", + nostd::string_view unit = "", + void *state = nullptr) noexcept override; + + nostd::shared_ptr<opentelemetry::metrics::Histogram<long>> CreateLongHistogram( + nostd::string_view name, + nostd::string_view description = "", + nostd::string_view unit = "") noexcept override; + + nostd::shared_ptr<opentelemetry::metrics::Histogram<double>> CreateDoubleHistogram( + nostd::string_view name, + nostd::string_view description = "", + nostd::string_view unit = "") noexcept override; + + void CreateLongObservableGauge(nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<long> &, + void *), + nostd::string_view description = "", + nostd::string_view unit = "", + void *state = nullptr) noexcept override; + + void CreateDoubleObservableGauge( + nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<double> &, void *), + nostd::string_view description = "", + nostd::string_view unit = "", + void *state = nullptr) noexcept override; + + nostd::shared_ptr<opentelemetry::metrics::UpDownCounter<long>> CreateLongUpDownCounter( + nostd::string_view name, + nostd::string_view description = "", + nostd::string_view unit = "") noexcept override; + + nostd::shared_ptr<opentelemetry::metrics::UpDownCounter<double>> CreateDoubleUpDownCounter( + nostd::string_view name, + nostd::string_view description = "", + nostd::string_view unit = "") noexcept override; + + void CreateLongObservableUpDownCounter( + nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<long> &, void *), + nostd::string_view description = "", + nostd::string_view unit = "", + void *state = nullptr) noexcept override; + + void CreateDoubleObservableUpDownCounter( + nostd::string_view name, + void (*callback)(opentelemetry::metrics::ObserverResult<double> &, void *), + nostd::string_view description = "", + nostd::string_view unit = "", + void *state = nullptr) noexcept override; + + /** Returns the associated instruementation library */ + const sdk::instrumentationlibrary::InstrumentationLibrary *GetInstrumentationLibrary() + const noexcept; + + /** collect metrics across all the instruments configured for the meter **/ + std::vector<MetricData> Collect(CollectorHandle *collector, + opentelemetry::common::SystemTimestamp collect_ts) noexcept; + +private: + // order of declaration is important here - instrumentation library should destroy after + // meter-context. + std::unique_ptr<sdk::instrumentationlibrary::InstrumentationLibrary> instrumentation_library_; + std::shared_ptr<sdk::metrics::MeterContext> meter_context_; + // Mapping between instrument-name and Aggregation Storage. + std::unordered_map<std::string, std::shared_ptr<MetricStorage>> storage_registry_; + + std::unique_ptr<WritableMetricStorage> RegisterMetricStorage( + InstrumentDescriptor &instrument_descriptor); + + template <class T> + void RegisterAsyncMetricStorage(InstrumentDescriptor &instrument_descriptor, + void (*callback)(opentelemetry::metrics::ObserverResult<T> &, + void *), + void *state = nullptr) + { + auto view_registry = meter_context_->GetViewRegistry(); + auto success = view_registry->FindViews( + instrument_descriptor, *instrumentation_library_, + [this, &instrument_descriptor, callback, state](const View &view) { + auto view_instr_desc = instrument_descriptor; + if (!view.GetName().empty()) + { + view_instr_desc.name_ = view.GetName(); + } + if (!view.GetDescription().empty()) + { + view_instr_desc.description_ = view.GetDescription(); + } + auto storage = std::shared_ptr<AsyncMetricStorage<T>>( + new AsyncMetricStorage<T>(view_instr_desc, view.GetAggregationType(), callback, + &view.GetAttributesProcessor(), state)); + storage_registry_[instrument_descriptor.name_] = storage; + return true; + }); + } +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/meter_context.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/meter_context.h new file mode 100644 index 000000000..e35700175 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/meter_context.h @@ -0,0 +1,133 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW + +# include "opentelemetry/common/spin_lock_mutex.h" +# include "opentelemetry/sdk/metrics/state/metric_collector.h" +# include "opentelemetry/sdk/metrics/view/instrument_selector.h" +# include "opentelemetry/sdk/metrics/view/meter_selector.h" +# include "opentelemetry/sdk/metrics/view/view_registry.h" +# include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/version.h" + +# include <chrono> +# include <memory> +# include <vector> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +// forward declaration +class Meter; +class MetricReader; + +/** + * A class which stores the MeterProvider context. + + */ +class MeterContext : public std::enable_shared_from_this<MeterContext> +{ +public: + /** + * Initialize a new meter provider + * @param readers The readers to be configured with meter context. + * @param views The views to be configured with meter context. + * @param resource The resource for this meter context. + */ + MeterContext( + std::unique_ptr<ViewRegistry> views = std::unique_ptr<ViewRegistry>(new ViewRegistry()), + opentelemetry::sdk::resource::Resource resource = + opentelemetry::sdk::resource::Resource::Create({})) noexcept; + + /** + * Obtain the resource associated with this meter context. + * @return The resource for this meter context + */ + const opentelemetry::sdk::resource::Resource &GetResource() const noexcept; + + /** + * Obtain the View Registry configured + * @return The reference to view registry + */ + ViewRegistry *GetViewRegistry() const noexcept; + + /** + * Obtain the configured meters. + * + */ + nostd::span<std::shared_ptr<Meter>> GetMeters() noexcept; + + /** + * Obtain the configured collectors. + * + */ + nostd::span<std::shared_ptr<CollectorHandle>> GetCollectors() noexcept; + + /** + * GET SDK Start time + * + */ + opentelemetry::common::SystemTimestamp GetSDKStartTime() noexcept; + + /** + * Attaches a metric reader to list of configured readers for this Meter context. + * @param reader The metric reader for this meter context. This + * must not be a nullptr. + * + * Note: This reader may not receive any in-flight meter data, but will get newly created meter + * data. Note: This method is not thread safe, and should ideally be called from main thread. + */ + void AddMetricReader(std::unique_ptr<MetricReader> reader) noexcept; + + /** + * Attaches a View to list of configured Views for this Meter context. + * @param view The Views for this meter context. This + * must not be a nullptr. + * + * Note: This view may not receive any in-flight meter data, but will get newly created meter + * data. Note: This method is not thread safe, and should ideally be called from main thread. + */ + void AddView(std::unique_ptr<InstrumentSelector> instrument_selector, + std::unique_ptr<MeterSelector> meter_selector, + std::unique_ptr<View> view) noexcept; + + /** + * Adds a meter to the list of configured meters. + * Note: This method is INTERNAL to sdk not thread safe. + * + * @param meter + */ + void AddMeter(std::shared_ptr<Meter> meter); + + /** + * Force all active Collectors to flush any buffered meter data + * within the given timeout. + */ + + bool ForceFlush(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept; + + /** + * Shutdown the Collectors associated with this meter provider. + */ + bool Shutdown() noexcept; + +private: + opentelemetry::sdk::resource::Resource resource_; + std::vector<std::shared_ptr<CollectorHandle>> collectors_; + std::unique_ptr<ViewRegistry> views_; + opentelemetry::common::SystemTimestamp sdk_start_ts_; + std::vector<std::shared_ptr<Meter>> meters_; + + std::atomic_flag shutdown_latch_ = ATOMIC_FLAG_INIT; + opentelemetry::common::SpinLockMutex forceflush_lock_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/meter_provider.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/meter_provider.h new file mode 100644 index 000000000..685f43e74 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/meter_provider.h @@ -0,0 +1,95 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include <memory> +# include <mutex> +# include <vector> +# include "opentelemetry/metrics/meter.h" +# include "opentelemetry/metrics/meter_provider.h" +# include "opentelemetry/nostd/shared_ptr.h" +# include "opentelemetry/sdk/metrics/meter.h" +# include "opentelemetry/sdk/metrics/meter_context.h" +# include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +// forward declaration +class MetricCollector; +class MetricReader; + +class MeterProvider final : public opentelemetry::metrics::MeterProvider +{ +public: + /** + * Initialize a new meter provider + * @param views The views for this meter provider + * @param resource The resources for this meter provider. + */ + MeterProvider( + std::unique_ptr<ViewRegistry> views = std::unique_ptr<ViewRegistry>(new ViewRegistry()), + sdk::resource::Resource resource = sdk::resource::Resource::Create({})) noexcept; + + /** + * Initialize a new meter provider with a specified context + * @param context The shared meter configuration/pipeline for this provider. + */ + explicit MeterProvider(std::shared_ptr<sdk::metrics::MeterContext> context) noexcept; + + nostd::shared_ptr<opentelemetry::metrics::Meter> GetMeter( + nostd::string_view name, + nostd::string_view version = "", + nostd::string_view schema_url = "") noexcept override; + + /** + * Obtain the resource associated with this meter provider. + * @return The resource for this meter provider. + */ + const sdk::resource::Resource &GetResource() const noexcept; + + /** + * Attaches a metric reader to list of configured readers for this Meter providers. + * @param reader The metric reader for this meter provider. This + * must not be a nullptr. + * + * Note: This reader may not receive any in-flight meter data, but will get newly created meter + * data. Note: This method is not thread safe, and should ideally be called from main thread. + */ + void AddMetricReader(std::unique_ptr<MetricReader> reader) noexcept; + + /** + * Attaches a View to list of configured Views for this Meter provider. + * @param view The Views for this meter provider. This + * must not be a nullptr. + * + * Note: This view may not receive any in-flight meter data, but will get newly created meter + * data. Note: This method is not thread safe, and should ideally be called from main thread. + */ + void AddView(std::unique_ptr<InstrumentSelector> instrument_selector, + std::unique_ptr<MeterSelector> meter_selector, + std::unique_ptr<View> view) noexcept; + + /** + * Shutdown the meter provider. + */ + bool Shutdown() noexcept; + + /** + * Force flush the meter provider. + */ + bool ForceFlush(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept; + +private: + std::shared_ptr<sdk::metrics::MeterContext> context_; + std::mutex lock_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/metric_exporter.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/metric_exporter.h new file mode 100644 index 000000000..3217b83df --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/metric_exporter.h @@ -0,0 +1,55 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW + +# include "opentelemetry/nostd/span.h" +# include "opentelemetry/sdk/common/exporter_utils.h" +# include "opentelemetry/sdk/metrics/export/metric_producer.h" +# include "opentelemetry/version.h" + +# include <chrono> +# include <memory> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class MetricData; +/** + * MetricExporter defines the interface to be used by metrics libraries to + * push metrics data to the OpenTelemetry exporters. + */ +class MetricExporter +{ +public: + virtual ~MetricExporter() = default; + + /** + * Exports a batch of metrics data. This method must not be called + * concurrently for the same exporter instance. + * @param data metrics data + */ + virtual opentelemetry::sdk::common::ExportResult Export(const ResourceMetrics &data) noexcept = 0; + + /** + * Force flush the exporter. + */ + virtual bool ForceFlush( + std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept = 0; + + /** + * Shut down the metric exporter. + * @param timeout an optional timeout. + * @return return the status of the operation. + */ + virtual bool Shutdown( + std::chrono::microseconds timeout = std::chrono::microseconds(0)) noexcept = 0; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/metric_reader.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/metric_reader.h new file mode 100644 index 000000000..94924315f --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/metric_reader.h @@ -0,0 +1,72 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/spin_lock_mutex.h" +# include "opentelemetry/sdk/common/global_log_handler.h" +# include "opentelemetry/sdk/metrics/data/metric_data.h" +# include "opentelemetry/sdk/metrics/export/metric_producer.h" +# include "opentelemetry/sdk/metrics/instruments.h" +# include "opentelemetry/version.h" + +# include <chrono> +# include <memory> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +/** + * MetricReader defines the interface to collect metrics from SDK + */ +class MetricReader +{ +public: + MetricReader( + AggregationTemporality aggregation_temporality = AggregationTemporality::kCumulative); + + void SetMetricProducer(MetricProducer *metric_producer); + + /** + * Collect the metrics from SDK. + * @return return the status of the operation. + */ + bool Collect(nostd::function_ref<bool(ResourceMetrics &metric_data)> callback) noexcept; + + AggregationTemporality GetAggregationTemporality() const noexcept; + + /** + * Shutdown the meter reader. + */ + bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept; + + /** + * Force flush the metric read by the reader. + */ + bool ForceFlush(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept; + + virtual ~MetricReader() = default; + +private: + virtual bool OnForceFlush(std::chrono::microseconds timeout) noexcept = 0; + + virtual bool OnShutDown(std::chrono::microseconds timeout) noexcept = 0; + + virtual void OnInitialized() noexcept {} + +protected: + bool IsShutdown() const noexcept; + +private: + MetricProducer *metric_producer_; + AggregationTemporality aggregation_temporality_; + mutable opentelemetry::common::SpinLockMutex lock_; + bool shutdown_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/observer_result.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/observer_result.h new file mode 100644 index 000000000..ca7227bc5 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/observer_result.h @@ -0,0 +1,48 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/key_value_iterable.h" +# include "opentelemetry/metrics/observer_result.h" +# include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" +# include "opentelemetry/sdk/metrics/view/attributes_processor.h" + +# include <map> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +template <class T> +class ObserverResult final : public opentelemetry::metrics::ObserverResult<T> +{ +public: + ObserverResult(const AttributesProcessor *attributes_processor) + : attributes_processor_(attributes_processor) + {} + + void Observe(T value) noexcept override { data_.insert({{}, value}); } + + void Observe(T value, const opentelemetry::common::KeyValueIterable &attributes) noexcept override + { + auto attr = attributes_processor_->process(attributes); + data_.insert({attr, value}); + } + + const std::unordered_map<MetricAttributes, T, AttributeHashGenerator> &GetMeasurements() + { + return data_; + } + +private: + std::unordered_map<MetricAttributes, T, AttributeHashGenerator> data_; + + const AttributesProcessor *attributes_processor_; +}; +} // namespace metrics +} // namespace sdk + +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h new file mode 100644 index 000000000..e5dcbc273 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h @@ -0,0 +1,95 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/sdk/common/attributemap_hash.h" +# include "opentelemetry/sdk/metrics/aggregation/default_aggregation.h" +# include "opentelemetry/sdk/metrics/instruments.h" +# include "opentelemetry/sdk/metrics/observer_result.h" +# include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" +# include "opentelemetry/sdk/metrics/state/metric_collector.h" +# include "opentelemetry/sdk/metrics/state/metric_storage.h" +# include "opentelemetry/sdk/metrics/state/temporal_metric_storage.h" +# include "opentelemetry/sdk/metrics/view/attributes_processor.h" + +# include <memory> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +template <class T> +class AsyncMetricStorage : public MetricStorage +{ +public: + AsyncMetricStorage(InstrumentDescriptor instrument_descriptor, + const AggregationType aggregation_type, + void (*measurement_callback)(opentelemetry::metrics::ObserverResult<T> &, + void *), + const AttributesProcessor *attributes_processor, + void *state = nullptr) + : instrument_descriptor_(instrument_descriptor), + aggregation_type_{aggregation_type}, + measurement_collection_callback_{measurement_callback}, + attributes_processor_{attributes_processor}, + state_{state}, + cumulative_hash_map_(new AttributesHashMap()), + temporal_metric_storage_(instrument_descriptor) + {} + + bool Collect(CollectorHandle *collector, + nostd::span<std::shared_ptr<CollectorHandle>> collectors, + opentelemetry::common::SystemTimestamp sdk_start_ts, + opentelemetry::common::SystemTimestamp collection_ts, + nostd::function_ref<bool(MetricData)> metric_collection_callback) noexcept override + { + opentelemetry::sdk::metrics::ObserverResult<T> ob_res(attributes_processor_); + + // read the measurement using configured callback + measurement_collection_callback_(ob_res, state_); + std::shared_ptr<AttributesHashMap> delta_hash_map(new AttributesHashMap()); + // process the read measurements - aggregate and store in hashmap + for (auto &measurement : ob_res.GetMeasurements()) + { + auto aggr = DefaultAggregation::CreateAggregation(aggregation_type_, instrument_descriptor_); + aggr->Aggregate(measurement.second); + auto prev = cumulative_hash_map_->Get(measurement.first); + if (prev) + { + auto delta = prev->Diff(*aggr); + cumulative_hash_map_->Set(measurement.first, + DefaultAggregation::CloneAggregation( + aggregation_type_, instrument_descriptor_, *delta)); + delta_hash_map->Set(measurement.first, std::move(delta)); + } + else + { + cumulative_hash_map_->Set( + measurement.first, + DefaultAggregation::CloneAggregation(aggregation_type_, instrument_descriptor_, *aggr)); + delta_hash_map->Set(measurement.first, std::move(aggr)); + } + } + + return temporal_metric_storage_.buildMetrics(collector, collectors, sdk_start_ts, collection_ts, + std::move(delta_hash_map), + metric_collection_callback); + } + +private: + InstrumentDescriptor instrument_descriptor_; + AggregationType aggregation_type_; + void (*measurement_collection_callback_)(opentelemetry::metrics::ObserverResult<T> &, void *); + const AttributesProcessor *attributes_processor_; + void *state_; + std::unique_ptr<AttributesHashMap> cumulative_hash_map_; + TemporalMetricStorage temporal_metric_storage_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/attributes_hashmap.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/attributes_hashmap.h new file mode 100644 index 000000000..50d40e0ae --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/attributes_hashmap.h @@ -0,0 +1,124 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/spin_lock_mutex.h" +# include "opentelemetry/nostd/function_ref.h" +# include "opentelemetry/sdk/common/attribute_utils.h" +# include "opentelemetry/sdk/common/attributemap_hash.h" +# include "opentelemetry/sdk/metrics/aggregation/aggregation.h" +# include "opentelemetry/sdk/metrics/instruments.h" +# include "opentelemetry/version.h" + +# include <functional> +# include <memory> +# include <mutex> +# include <unordered_map> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +using opentelemetry::sdk::common::OrderedAttributeMap; + +class AttributeHashGenerator +{ +public: + size_t operator()(const MetricAttributes &attributes) const + { + return opentelemetry::sdk::common::GetHashForAttributeMap(attributes); + } +}; + +class AttributesHashMap +{ +public: + Aggregation *Get(const MetricAttributes &attributes) const + { + std::lock_guard<opentelemetry::common::SpinLockMutex> guard(lock_); + auto it = hash_map_.find(attributes); + if (it != hash_map_.end()) + { + return it->second.get(); + } + return nullptr; + } + + /** + * @return check if key is present in hash + * + */ + bool Has(const MetricAttributes &attributes) const + { + std::lock_guard<opentelemetry::common::SpinLockMutex> guard(lock_); + return (hash_map_.find(attributes) == hash_map_.end()) ? false : true; + } + + /** + * @return the pointer to value for given key if present. + * If not present, it uses the provided callback to generate + * value and store in the hash + */ + Aggregation *GetOrSetDefault(const MetricAttributes &attributes, + std::function<std::unique_ptr<Aggregation>()> aggregation_callback) + { + std::lock_guard<opentelemetry::common::SpinLockMutex> guard(lock_); + + auto it = hash_map_.find(attributes); + if (it != hash_map_.end()) + { + return it->second.get(); + } + + hash_map_[attributes] = std::move(aggregation_callback()); + return hash_map_[attributes].get(); + } + + /** + * Set the value for given key, overwriting the value if already present + */ + void Set(const MetricAttributes &attributes, std::unique_ptr<Aggregation> value) + { + std::lock_guard<opentelemetry::common::SpinLockMutex> guard(lock_); + hash_map_[attributes] = std::move(value); + } + + /** + * Iterate the hash to yield key and value stored in hash. + */ + bool GetAllEnteries( + nostd::function_ref<bool(const MetricAttributes &, Aggregation &)> callback) const + { + std::lock_guard<opentelemetry::common::SpinLockMutex> guard(lock_); + for (auto &kv : hash_map_) + { + if (!callback(kv.first, *(kv.second.get()))) + { + return false; // callback is not prepared to consume data + } + } + return true; + } + + /** + * Return the size of hash. + */ + size_t Size() + { + std::lock_guard<opentelemetry::common::SpinLockMutex> guard(lock_); + return hash_map_.size(); + } + +private: + std::unordered_map<MetricAttributes, std::unique_ptr<Aggregation>, AttributeHashGenerator> + hash_map_; + + mutable opentelemetry::common::SpinLockMutex lock_; +}; +} // namespace metrics + +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/metric_collector.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/metric_collector.h new file mode 100644 index 000000000..20372f520 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/metric_collector.h @@ -0,0 +1,57 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/sdk/metrics/data/metric_data.h" +# include "opentelemetry/sdk/metrics/export/metric_producer.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class MetricReader; +class MeterContext; + +class CollectorHandle +{ +public: + virtual AggregationTemporality GetAggregationTemporality() noexcept = 0; +}; + +/** + * An internal opaque interface that the MetricReader receives as + * MetricProducer. It acts as the storage key to the internal metric stream + * state for each MetricReader. + */ + +class MetricCollector : public MetricProducer, public CollectorHandle +{ +public: + MetricCollector(std::shared_ptr<MeterContext> &&context, + std::unique_ptr<MetricReader> metric_reader); + + AggregationTemporality GetAggregationTemporality() noexcept override; + + /** + * The callback to be called for each metric exporter. This will only be those + * metrics that have been produced since the last time this method was called. + * + * @return a status of completion of method. + */ + bool Collect(nostd::function_ref<bool(ResourceMetrics &metric_data)> callback) noexcept override; + + bool ForceFlush(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept; + + bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept; + +private: + std::shared_ptr<MeterContext> meter_context_; + std::shared_ptr<MetricReader> metric_reader_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h new file mode 100644 index 000000000..e0ba55cbf --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h @@ -0,0 +1,86 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/key_value_iterable_view.h" +# include "opentelemetry/common/timestamp.h" +# include "opentelemetry/context/context.h" +# include "opentelemetry/sdk/metrics/data/metric_data.h" +# include "opentelemetry/sdk/metrics/instruments.h" +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +/* Represent the storage from which to collect the metrics */ +class CollectorHandle; + +class MetricStorage +{ +public: + /* collect the metrics from this storage */ + virtual bool Collect(CollectorHandle *collector, + nostd::span<std::shared_ptr<CollectorHandle>> collectors, + opentelemetry::common::SystemTimestamp sdk_start_ts, + opentelemetry::common::SystemTimestamp collection_ts, + nostd::function_ref<bool(MetricData)> callback) noexcept = 0; +}; + +class WritableMetricStorage +{ +public: + virtual void RecordLong(long value, const opentelemetry::context::Context &context) noexcept = 0; + + virtual void RecordLong(long value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept = 0; + + virtual void RecordDouble(double value, + const opentelemetry::context::Context &context) noexcept = 0; + + virtual void RecordDouble(double value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept = 0; + + virtual ~WritableMetricStorage() = default; +}; + +class NoopMetricStorage : public MetricStorage +{ +public: + bool Collect(CollectorHandle *collector, + nostd::span<std::shared_ptr<CollectorHandle>> collectors, + opentelemetry::common::SystemTimestamp sdk_start_ts, + opentelemetry::common::SystemTimestamp collection_ts, + nostd::function_ref<bool(MetricData)> callback) noexcept override + { + MetricData metric_data; + return callback(std::move(metric_data)); + } +}; + +class NoopWritableMetricStorage : public WritableMetricStorage +{ +public: + void RecordLong(long value, const opentelemetry::context::Context &context) noexcept = 0; + + void RecordLong(long value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override + {} + + void RecordDouble(double value, const opentelemetry::context::Context &context) noexcept override + {} + + void RecordDouble(double value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override + {} +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h new file mode 100644 index 000000000..ceeafa040 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h @@ -0,0 +1,68 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/key_value_iterable_view.h" +# include "opentelemetry/sdk/metrics/instruments.h" +# include "opentelemetry/sdk/metrics/state/metric_storage.h" + +# include <memory> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +class MultiMetricStorage : public WritableMetricStorage +{ +public: + void AddStorage(std::shared_ptr<WritableMetricStorage> storage) { storages_.push_back(storage); } + + virtual void RecordLong(long value, + const opentelemetry::context::Context &context) noexcept override + { + for (auto &s : storages_) + { + s->RecordLong(value, context); + } + } + + virtual void RecordLong(long value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override + { + for (auto &s : storages_) + { + s->RecordLong(value, attributes, context); + } + } + + virtual void RecordDouble(double value, + const opentelemetry::context::Context &context) noexcept override + { + for (auto &s : storages_) + { + s->RecordDouble(value, context); + } + } + + virtual void RecordDouble(double value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override + { + for (auto &s : storages_) + { + s->RecordDouble(value, attributes, context); + } + } + +private: + std::vector<std::shared_ptr<WritableMetricStorage>> storages_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/sync_metric_storage.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/sync_metric_storage.h new file mode 100644 index 000000000..278f7dbe3 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/sync_metric_storage.h @@ -0,0 +1,119 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/key_value_iterable_view.h" +# include "opentelemetry/sdk/common/attributemap_hash.h" +# include "opentelemetry/sdk/metrics/aggregation/default_aggregation.h" +# include "opentelemetry/sdk/metrics/exemplar/reservoir.h" +# include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" +# include "opentelemetry/sdk/metrics/state/metric_collector.h" +# include "opentelemetry/sdk/metrics/state/metric_storage.h" + +# include "opentelemetry/sdk/metrics/state/temporal_metric_storage.h" +# include "opentelemetry/sdk/metrics/view/attributes_processor.h" + +# include <list> +# include <memory> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class SyncMetricStorage : public MetricStorage, public WritableMetricStorage +{ + +public: + SyncMetricStorage(InstrumentDescriptor instrument_descriptor, + const AggregationType aggregation_type, + const AttributesProcessor *attributes_processor, + nostd::shared_ptr<ExemplarReservoir> &&exemplar_reservoir) + : instrument_descriptor_(instrument_descriptor), + aggregation_type_{aggregation_type}, + attributes_hashmap_(new AttributesHashMap()), + attributes_processor_{attributes_processor}, + exemplar_reservoir_(exemplar_reservoir), + temporal_metric_storage_(instrument_descriptor) + + { + create_default_aggregation_ = [&]() -> std::unique_ptr<Aggregation> { + return std::move( + DefaultAggregation::CreateAggregation(aggregation_type_, instrument_descriptor_)); + }; + } + + void RecordLong(long value, const opentelemetry::context::Context &context) noexcept override + { + if (instrument_descriptor_.value_type_ != InstrumentValueType::kLong) + { + return; + } + exemplar_reservoir_->OfferMeasurement(value, {}, context, std::chrono::system_clock::now()); + attributes_hashmap_->GetOrSetDefault({}, create_default_aggregation_)->Aggregate(value); + } + + void RecordLong(long value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override + { + if (instrument_descriptor_.value_type_ != InstrumentValueType::kLong) + { + return; + } + + exemplar_reservoir_->OfferMeasurement(value, attributes, context, + std::chrono::system_clock::now()); + auto attr = attributes_processor_->process(attributes); + attributes_hashmap_->GetOrSetDefault(attr, create_default_aggregation_)->Aggregate(value); + } + + void RecordDouble(double value, const opentelemetry::context::Context &context) noexcept override + { + if (instrument_descriptor_.value_type_ != InstrumentValueType::kDouble) + { + return; + } + exemplar_reservoir_->OfferMeasurement(value, {}, context, std::chrono::system_clock::now()); + attributes_hashmap_->GetOrSetDefault({}, create_default_aggregation_)->Aggregate(value); + } + + void RecordDouble(double value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override + { + exemplar_reservoir_->OfferMeasurement(value, attributes, context, + std::chrono::system_clock::now()); + if (instrument_descriptor_.value_type_ != InstrumentValueType::kDouble) + { + return; + } + exemplar_reservoir_->OfferMeasurement(value, attributes, context, + std::chrono::system_clock::now()); + auto attr = attributes_processor_->process(attributes); + attributes_hashmap_->GetOrSetDefault(attr, create_default_aggregation_)->Aggregate(value); + } + + bool Collect(CollectorHandle *collector, + nostd::span<std::shared_ptr<CollectorHandle>> collectors, + opentelemetry::common::SystemTimestamp sdk_start_ts, + opentelemetry::common::SystemTimestamp collection_ts, + nostd::function_ref<bool(MetricData)> callback) noexcept override; + +private: + InstrumentDescriptor instrument_descriptor_; + AggregationType aggregation_type_; + + // hashmap to maintain the metrics for delta collection (i.e, collection since last Collect call) + std::unique_ptr<AttributesHashMap> attributes_hashmap_; + const AttributesProcessor *attributes_processor_; + std::function<std::unique_ptr<Aggregation>()> create_default_aggregation_; + nostd::shared_ptr<ExemplarReservoir> exemplar_reservoir_; + TemporalMetricStorage temporal_metric_storage_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/temporal_metric_storage.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/temporal_metric_storage.h new file mode 100644 index 000000000..16659c14f --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/state/temporal_metric_storage.h @@ -0,0 +1,50 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" +# include "opentelemetry/sdk/metrics/state/metric_collector.h" + +# include <memory> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +struct LastReportedMetrics +{ + std::unique_ptr<AttributesHashMap> attributes_map; + opentelemetry::common::SystemTimestamp collection_ts; +}; + +class TemporalMetricStorage +{ +public: + TemporalMetricStorage(InstrumentDescriptor instrument_descriptor); + + bool buildMetrics(CollectorHandle *collector, + nostd::span<std::shared_ptr<CollectorHandle>> collectors, + opentelemetry::common::SystemTimestamp sdk_start_ts, + opentelemetry::common::SystemTimestamp collection_ts, + std::shared_ptr<AttributesHashMap> delta_metrics, + nostd::function_ref<bool(MetricData)> callback) noexcept; + +private: + InstrumentDescriptor instrument_descriptor_; + + // unreported metrics stash for all the collectors + std::unordered_map<CollectorHandle *, std::list<std::shared_ptr<AttributesHashMap>>> + unreported_metrics_; + // last reported metrics stash for all the collectors. + std::unordered_map<CollectorHandle *, LastReportedMetrics> last_reported_metrics_; + + // Lock while building metrics + mutable opentelemetry::common::SpinLockMutex lock_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/sync_instruments.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/sync_instruments.h new file mode 100644 index 000000000..f4c9bae32 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/sync_instruments.h @@ -0,0 +1,127 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/common/key_value_iterable.h" +# include "opentelemetry/metrics/sync_instruments.h" +# include "opentelemetry/nostd/string_view.h" +# include "opentelemetry/sdk/metrics/instruments.h" + +# include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +// forward declaration +class WritableMetricStorage; + +class Synchronous +{ +public: + Synchronous(InstrumentDescriptor instrument_descriptor, + std::unique_ptr<WritableMetricStorage> storage) + : instrument_descriptor_(instrument_descriptor), storage_(std::move(storage)) + {} + +protected: + InstrumentDescriptor instrument_descriptor_; + std::unique_ptr<WritableMetricStorage> storage_; +}; + +class LongCounter : public Synchronous, public opentelemetry::metrics::Counter<long> +{ +public: + LongCounter(InstrumentDescriptor instrument_descriptor, + std::unique_ptr<WritableMetricStorage> storage); + + void Add(long value, const opentelemetry::common::KeyValueIterable &attributes) noexcept override; + void Add(long value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override; + + void Add(long value) noexcept override; + void Add(long value, const opentelemetry::context::Context &context) noexcept override; +}; + +class DoubleCounter : public Synchronous, public opentelemetry::metrics::Counter<double> +{ + +public: + DoubleCounter(InstrumentDescriptor instrument_descriptor, + std::unique_ptr<WritableMetricStorage> storage); + + void Add(double value, + const opentelemetry::common::KeyValueIterable &attributes) noexcept override; + void Add(double value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override; + + void Add(double value) noexcept override; + void Add(double value, const opentelemetry::context::Context &context) noexcept override; +}; + +class LongUpDownCounter : public Synchronous, public opentelemetry::metrics::UpDownCounter<long> +{ +public: + LongUpDownCounter(InstrumentDescriptor instrument_descriptor, + std::unique_ptr<WritableMetricStorage> storage); + + void Add(long value, const opentelemetry::common::KeyValueIterable &attributes) noexcept override; + void Add(long value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override; + + void Add(long value) noexcept override; + void Add(long value, const opentelemetry::context::Context &context) noexcept override; +}; + +class DoubleUpDownCounter : public Synchronous, public opentelemetry::metrics::UpDownCounter<double> +{ +public: + DoubleUpDownCounter(InstrumentDescriptor instrument_descriptor, + std::unique_ptr<WritableMetricStorage> storage); + + void Add(double value, + const opentelemetry::common::KeyValueIterable &attributes) noexcept override; + void Add(double value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override; + + void Add(double value) noexcept override; + void Add(double value, const opentelemetry::context::Context &context) noexcept override; +}; + +class LongHistogram : public Synchronous, public opentelemetry::metrics::Histogram<long> +{ +public: + LongHistogram(InstrumentDescriptor instrument_descriptor, + std::unique_ptr<WritableMetricStorage> storage); + + void Record(long value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override; + + void Record(long value, const opentelemetry::context::Context &context) noexcept override; +}; + +class DoubleHistogram : public Synchronous, public opentelemetry::metrics::Histogram<double> +{ +public: + DoubleHistogram(InstrumentDescriptor instrument_descriptor, + std::unique_ptr<WritableMetricStorage> storage); + + void Record(double value, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::context::Context &context) noexcept override; + + void Record(double value, const opentelemetry::context::Context &context) noexcept override; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/attributes_processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/attributes_processor.h new file mode 100644 index 000000000..d82607357 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/attributes_processor.h @@ -0,0 +1,81 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/sdk/common/attribute_utils.h" +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +using MetricAttributes = opentelemetry::sdk::common::OrderedAttributeMap; + +/** + * The AttributesProcessor is responsible for customizing which + * attribute(s) are to be reported as metrics dimension(s). + */ + +class AttributesProcessor +{ +public: + // Process the metric instrument attributes. + // @returns The processed attributes + virtual MetricAttributes process( + const opentelemetry::common::KeyValueIterable &attributes) const noexcept = 0; + + virtual ~AttributesProcessor() = default; +}; + +/** + * DefaultAttributesProcessor returns copy of input instrument attributes without + * any modification. + */ + +class DefaultAttributesProcessor : public AttributesProcessor +{ + MetricAttributes process( + const opentelemetry::common::KeyValueIterable &attributes) const noexcept override + { + MetricAttributes result(attributes); + return result; + } +}; + +/** + * FilteringAttributesProcessor filters by allowed attribute names and drops any names + * that are not in the allow list. + */ + +class FilteringAttributesProcessor : public AttributesProcessor +{ +public: + FilteringAttributesProcessor( + const std::unordered_map<std::string, bool> allowed_attribute_keys = {}) + : allowed_attribute_keys_(std::move(allowed_attribute_keys)) + {} + + MetricAttributes process( + const opentelemetry::common::KeyValueIterable &attributes) const noexcept override + { + MetricAttributes result; + attributes.ForEachKeyValue( + [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept { + if (allowed_attribute_keys_.find(key.data()) != allowed_attribute_keys_.end()) + { + result.SetAttribute(key, value); + return true; + } + return true; + }); + return result; + } + +private: + std::unordered_map<std::string, bool> allowed_attribute_keys_; +}; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/instrument_selector.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/instrument_selector.h new file mode 100644 index 000000000..e79a292c0 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/instrument_selector.h @@ -0,0 +1,36 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/nostd/string_view.h" +# include "opentelemetry/sdk/metrics/instruments.h" +# include "opentelemetry/sdk/metrics/view/predicate_factory.h" +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class InstrumentSelector +{ +public: + InstrumentSelector(opentelemetry::sdk::metrics::InstrumentType instrument_type, + opentelemetry::nostd::string_view name) + : name_filter_{std::move(PredicateFactory::GetPredicate(name, PredicateType::kPattern))}, + instrument_type_{instrument_type} + {} + + // Returns name filter predicate. This shouldn't be deleted + const opentelemetry::sdk::metrics::Predicate *const GetNameFilter() { return name_filter_.get(); } + + // Returns instrument filter. + InstrumentType GetInstrumentType() { return instrument_type_; } + +private: + std::unique_ptr<opentelemetry::sdk::metrics::Predicate> name_filter_; + opentelemetry::sdk::metrics::InstrumentType instrument_type_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/meter_selector.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/meter_selector.h new file mode 100644 index 000000000..d0bc07ccb --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/meter_selector.h @@ -0,0 +1,47 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/sdk/metrics/view/predicate_factory.h" +#ifndef ENABLE_METRICS_PREVIEW +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class MeterSelector +{ +public: + MeterSelector(opentelemetry::nostd::string_view name, + opentelemetry::nostd::string_view version, + opentelemetry::nostd::string_view schema) + : name_filter_{std::move(PredicateFactory::GetPredicate(name, PredicateType::kExact))}, + version_filter_{std::move(PredicateFactory::GetPredicate(version, PredicateType::kExact))}, + schema_filter_{std::move(PredicateFactory::GetPredicate(schema, PredicateType::kExact))} + {} + + // Returns name filter predicate. This shouldn't be deleted + const opentelemetry::sdk::metrics::Predicate *const GetNameFilter() { return name_filter_.get(); } + + // Returns version filter predicate. This shouldn't be deleted + const opentelemetry::sdk::metrics::Predicate *const GetVersionFilter() + { + return version_filter_.get(); + } + + // Returns schema filter predicate. This shouldn't be deleted + const opentelemetry::sdk::metrics::Predicate *const GetSchemaFilter() + { + return schema_filter_.get(); + } + +private: + std::unique_ptr<opentelemetry::sdk::metrics::Predicate> name_filter_; + std::unique_ptr<opentelemetry::sdk::metrics::Predicate> version_filter_; + std::unique_ptr<opentelemetry::sdk::metrics::Predicate> schema_filter_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/predicate.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/predicate.h new file mode 100644 index 000000000..72de2979a --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/predicate.h @@ -0,0 +1,82 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include <vector> +# if (__GNUC__ == 4 && (__GNUC_MINOR__ == 8 || __GNUC_MINOR__ == 9)) +# define HAVE_WORKING_REGEX 0 +# include "opentelemetry/sdk/common/global_log_handler.h" +# else +# include <regex> +# define HAVE_WORKING_REGEX 1 +# endif + +# include "opentelemetry/nostd/string_view.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +class Predicate +{ +public: + virtual ~Predicate() = default; + virtual bool Match(opentelemetry::nostd::string_view string) const noexcept = 0; +}; + +class PatternPredicate : public Predicate +{ +public: + PatternPredicate(opentelemetry::nostd::string_view pattern) : reg_key_{pattern.data()} {} + bool Match(opentelemetry::nostd::string_view str) const noexcept override + { +# if HAVE_WORKING_REGEX + return std::regex_match(str.data(), reg_key_); +# else + // TBD - Support regex match for GCC4.8 + OTEL_INTERNAL_LOG_ERROR( + "PatternPredicate::Match - failed. std::regex not fully supported for this compiler."); + return false; // not supported +# endif + } + +private: +# if HAVE_WORKING_REGEX + std::regex reg_key_; +# else + std::string reg_key_; +# endif +}; + +class ExactPredicate : public Predicate +{ +public: + ExactPredicate(opentelemetry::nostd::string_view pattern) : pattern_{pattern} {} + bool Match(opentelemetry::nostd::string_view str) const noexcept override + { + if (pattern_ == str) + { + return true; + } + return false; + } + +private: + std::string pattern_; +}; + +class MatchEverythingPattern : public Predicate +{ + bool Match(opentelemetry::nostd::string_view str) const noexcept override { return true; } +}; + +class MatchNothingPattern : public Predicate +{ + bool Match(opentelemetry::nostd::string_view str) const noexcept override { return false; } +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/predicate_factory.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/predicate_factory.h new file mode 100644 index 000000000..466fa76d5 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/predicate_factory.h @@ -0,0 +1,45 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/sdk/metrics/view/predicate.h" +#ifndef ENABLE_METRICS_PREVIEW +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +enum class PredicateType : uint8_t +{ + kPattern, + kExact +}; + +class PredicateFactory +{ +public: + static std::unique_ptr<Predicate> GetPredicate(opentelemetry::nostd::string_view pattern, + PredicateType type) + { + if ((type == PredicateType::kPattern && pattern == "*") || + (type == PredicateType::kExact && pattern == "")) + { + return std::move(std::unique_ptr<Predicate>(new MatchEverythingPattern())); + } + if (type == PredicateType::kPattern) + { + return std::move(std::unique_ptr<Predicate>(new PatternPredicate(pattern))); + } + if (type == PredicateType::kExact) + { + return std::move(std::unique_ptr<Predicate>(new ExactPredicate(pattern))); + } + return std::move(std::unique_ptr<Predicate>(new MatchNothingPattern())); + } +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/view.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/view.h new file mode 100644 index 000000000..3cd9f850e --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/view.h @@ -0,0 +1,57 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include "opentelemetry/nostd/string_view.h" +# include "opentelemetry/sdk/metrics/aggregation/default_aggregation.h" +# include "opentelemetry/sdk/metrics/instruments.h" +# include "opentelemetry/sdk/metrics/view/attributes_processor.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +/** + * View defines the interface to allow SDK user to + * customize the metrics before exported. + */ + +class View +{ +public: + View(const std::string &name, + const std::string &description = "", + AggregationType aggregation_type = AggregationType::kDefault, + std::unique_ptr<opentelemetry::sdk::metrics::AttributesProcessor> attributes_processor = + std::unique_ptr<opentelemetry::sdk::metrics::AttributesProcessor>( + new opentelemetry::sdk::metrics::DefaultAttributesProcessor())) + : name_(name), + description_(description), + aggregation_type_{aggregation_type}, + attributes_processor_{std::move(attributes_processor)} + {} + + virtual std::string GetName() const noexcept { return name_; } + + virtual std::string GetDescription() const noexcept { return description_; } + + virtual AggregationType GetAggregationType() const noexcept { return aggregation_type_; } + + virtual const opentelemetry::sdk::metrics::AttributesProcessor &GetAttributesProcessor() + const noexcept + { + return *attributes_processor_.get(); + } + +private: + std::string name_; + std::string description_; + AggregationType aggregation_type_; + std::unique_ptr<opentelemetry::sdk::metrics::AttributesProcessor> attributes_processor_; +}; +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/view_registry.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/view_registry.h new file mode 100644 index 000000000..795049dd9 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/metrics/view/view_registry.h @@ -0,0 +1,102 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#ifndef ENABLE_METRICS_PREVIEW +# include <unordered_map> +# include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h" +# include "opentelemetry/sdk/metrics/view/instrument_selector.h" +# include "opentelemetry/sdk/metrics/view/meter_selector.h" +# include "opentelemetry/sdk/metrics/view/view.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ +struct RegisteredView +{ + RegisteredView( + std::unique_ptr<opentelemetry::sdk::metrics::InstrumentSelector> instrument_selector, + std::unique_ptr<opentelemetry::sdk::metrics::MeterSelector> meter_selector, + std::unique_ptr<opentelemetry::sdk::metrics::View> view) + : instrument_selector_{std::move(instrument_selector)}, + meter_selector_{std::move(meter_selector)}, + view_{std::move(view)} + {} + std::unique_ptr<opentelemetry::sdk::metrics::InstrumentSelector> instrument_selector_; + std::unique_ptr<opentelemetry::sdk::metrics::MeterSelector> meter_selector_; + std::unique_ptr<opentelemetry::sdk::metrics::View> view_; +}; + +class ViewRegistry +{ +public: + void AddView(std::unique_ptr<opentelemetry::sdk::metrics::InstrumentSelector> instrument_selector, + std::unique_ptr<opentelemetry::sdk::metrics::MeterSelector> meter_selector, + std::unique_ptr<opentelemetry::sdk::metrics::View> view) + { + // TBD - thread-safe ? + + auto registered_view = std::unique_ptr<RegisteredView>(new RegisteredView{ + std::move(instrument_selector), std::move(meter_selector), std::move(view)}); + registered_views_.push_back(std::move(registered_view)); + } + + bool FindViews(const opentelemetry::sdk::metrics::InstrumentDescriptor &instrument_descriptor, + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary + &instrumentation_library, + nostd::function_ref<bool(const View &)> callback) const + { + bool found = false; + for (auto const ®istered_view : registered_views_) + { + if (MatchMeter(registered_view->meter_selector_.get(), instrumentation_library) && + MatchInstrument(registered_view->instrument_selector_.get(), instrument_descriptor)) + { + found = true; + if (!callback(*(registered_view->view_.get()))) + { + return false; + } + } + } + // return default view if none found; + if (!found) + { + static View view("otel-default-view"); + if (!callback(view)) + { + return false; + } + } + return true; + } + + ~ViewRegistry() = default; + +private: + std::vector<std::unique_ptr<RegisteredView>> registered_views_; + static bool MatchMeter(opentelemetry::sdk::metrics::MeterSelector *selector, + const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary + &instrumentation_library) + { + return selector->GetNameFilter()->Match(instrumentation_library.GetName()) && + (instrumentation_library.GetVersion().size() == 0 || + selector->GetVersionFilter()->Match(instrumentation_library.GetVersion())) && + (instrumentation_library.GetSchemaURL().size() == 0 || + selector->GetSchemaFilter()->Match(instrumentation_library.GetSchemaURL())); + } + + static bool MatchInstrument( + opentelemetry::sdk::metrics::InstrumentSelector *selector, + const opentelemetry::sdk::metrics::InstrumentDescriptor &instrument_descriptor) + { + return selector->GetNameFilter()->Match(instrument_descriptor.name_) && + (selector->GetInstrumentType() == instrument_descriptor.type_); + } +}; +}; // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/resource/experimental_semantic_conventions.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/resource/experimental_semantic_conventions.h new file mode 100644 index 000000000..d9dc3630f --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/resource/experimental_semantic_conventions.h @@ -0,0 +1,141 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// NOTE: +// This implementation is based on the experimental specs for resource semantic convention as +// defined here: +// https://github.com/open-telemetry/opentelemetry-specification/tree/v1.0.0/specification/resource/semantic_conventions +// and MAY will change in future. + +#pragma once + +#include <type_traits> +#include <unordered_map> + +#include "opentelemetry/common/string_util.h" +#include "opentelemetry/version.h" + +#define OTEL_GET_RESOURCE_ATTR(name) \ + opentelemetry::sdk::resource::attr(OTEL_CPP_CONST_HASHCODE(name)) + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace resource +{ + +static const std::unordered_map<uint32_t, const char *> attribute_ids = { + {OTEL_CPP_CONST_HASHCODE(AttrServiceName), "service.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrServiceNamespace), "service.namespace"}, + {OTEL_CPP_CONST_HASHCODE(AttrServiceInstance), "service.instance.id"}, + {OTEL_CPP_CONST_HASHCODE(AttrServiceVersion), "service.version"}, + + // telemetry attributes + {OTEL_CPP_CONST_HASHCODE(AttrTelemetrySdkName), "telemetry.sdk.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrTelemetrySdkLanguage), "telemetry.sdk.language"}, + {OTEL_CPP_CONST_HASHCODE(AttrTelemetrySdkVersion), "telemetry.sdk.version"}, + {OTEL_CPP_CONST_HASHCODE(AttrTelemetryAutoVersion), "telemetry.auto.version"}, + + // compute unit: container attributes + {OTEL_CPP_CONST_HASHCODE(AttrContainerName), "container.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrContainerId), "container.id"}, + {OTEL_CPP_CONST_HASHCODE(AttrContainerRuntime), "container.runtime"}, + {OTEL_CPP_CONST_HASHCODE(AttrContainerImageName), "container.image.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrContainerImageTag), "container.image.tag"}, + + // compute unit: faas attributes + {OTEL_CPP_CONST_HASHCODE(AttrFaasName), "faas.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrFaasId), "faas.id"}, + {OTEL_CPP_CONST_HASHCODE(AttrFaasVersion), "faas.version"}, + {OTEL_CPP_CONST_HASHCODE(AttrFaasInstance), "faas.instance"}, + {OTEL_CPP_CONST_HASHCODE(AttrFaasMaxMemory), "faas.max_memory"}, + + // compute unit : process attributes + {OTEL_CPP_CONST_HASHCODE(AttrProcessId), "process.pid"}, + {OTEL_CPP_CONST_HASHCODE(AttrProcessExecutableName), "process.executable.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrProcessExecutablePath), "process.executable.path"}, + {OTEL_CPP_CONST_HASHCODE(AttrProcessCommand), "process.command"}, + {OTEL_CPP_CONST_HASHCODE(AttrProcessCommandLine), "process.command_line"}, + {OTEL_CPP_CONST_HASHCODE(AttrProcessCommandArgs), "process.command_args"}, + {OTEL_CPP_CONST_HASHCODE(AttrProcessOwner), "process.owner"}, + + // compute : process runtimes + {OTEL_CPP_CONST_HASHCODE(AttrProcessRuntimeName), "process.runtime.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrProcessRuntimeVersion), "process.runtime.version"}, + {OTEL_CPP_CONST_HASHCODE(AttrProcessRuntimeDescription), "process.runtime.description"}, + + // compute unit : WebEngine + {OTEL_CPP_CONST_HASHCODE(AttrWebEngineName), "webengine.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrWebEngineVersion), "webengine.version"}, + {OTEL_CPP_CONST_HASHCODE(AttrWebEngineDescription), "webengine.description"}, + + // compute instance : host + {OTEL_CPP_CONST_HASHCODE(AttrHostId), "host.id"}, + {OTEL_CPP_CONST_HASHCODE(AttrHostName), "host.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrHostType), "host.type"}, + {OTEL_CPP_CONST_HASHCODE(AttrHostArch), "host.arch"}, + {OTEL_CPP_CONST_HASHCODE(AttrHostImageName), "host.image.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrHostImageId), "host.image.id"}, + {OTEL_CPP_CONST_HASHCODE(AttrHostImageVersion), "host.image.version"}, + + // env os attributes + {OTEL_CPP_CONST_HASHCODE(AttrOsType), "os.type"}, + {OTEL_CPP_CONST_HASHCODE(AttrOsDescription), "os.description"}, + {OTEL_CPP_CONST_HASHCODE(AttrOsName), "os.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrOsVersion), "os.version"}, + + // env device attributes + {OTEL_CPP_CONST_HASHCODE(AttrDeviceId), "device.id"}, + {OTEL_CPP_CONST_HASHCODE(AttrDeviceModelIdentifier), "device.model.identifier"}, + {OTEL_CPP_CONST_HASHCODE(AttrDeviceModelName), "device.model.name"}, + + // env cloud + {OTEL_CPP_CONST_HASHCODE(AttrCloudProvider), "cloud.provider"}, + {OTEL_CPP_CONST_HASHCODE(AttrCloudAccountId), "cloud.account.id"}, + {OTEL_CPP_CONST_HASHCODE(AttrCloudRegion), "cloud.region"}, + {OTEL_CPP_CONST_HASHCODE(AttrCloudAvailabilityZone), "cloud.availability_zone"}, + {OTEL_CPP_CONST_HASHCODE(AttrCloudPlatform), "cloud.platform"}, + + // env deployment + {OTEL_CPP_CONST_HASHCODE(AttrDeploymentEnvironment), "deployment.environment"}, + + // env kubernetes + // - cluster + {OTEL_CPP_CONST_HASHCODE(AttrK8sClusterName), "k8s.cluster.name"}, + // - node + {OTEL_CPP_CONST_HASHCODE(AttrK8sNodeName), "k8s.node.name"}, + {OTEL_CPP_CONST_HASHCODE(AttrK8sNodeUid), "k8s.node.uid"}, + // - namespace + {OTEL_CPP_CONST_HASHCODE(AttrK8sNamespaceName), "k8s.namespace.name"}, + // - pod + {OTEL_CPP_CONST_HASHCODE(AttrK8sPodUid), "k8s.pod.uid"}, + {OTEL_CPP_CONST_HASHCODE(AttrK8sPodName), "k8s.pod.name"}, + // - container + {OTEL_CPP_CONST_HASHCODE(AttrK8sContainerName), "k8s.container.name"}, + // - replicaset + {OTEL_CPP_CONST_HASHCODE(AttrK8sReplicaSetUid), "k8s.replicaset.uid"}, + {OTEL_CPP_CONST_HASHCODE(AttrK8sReplicaSetName), "k8s.replicaset.name"}, + // - deployment + {OTEL_CPP_CONST_HASHCODE(AttrK8sDeploymentUid), "k8s.deployment.uid"}, + {OTEL_CPP_CONST_HASHCODE(AttrK8sDeploymentName), "k8s.deployment.name"}, + // - stateful-set + {OTEL_CPP_CONST_HASHCODE(AttrK8sStatefulSetUid), "k8s.statefulset.uid"}, + {OTEL_CPP_CONST_HASHCODE(AttrK8sStatefulSetName), "k8s.statefulset.name"}, + // - daemon set + {OTEL_CPP_CONST_HASHCODE(AttrK8sDaemonSetUid), "k8s.daemonset.uid"}, + {OTEL_CPP_CONST_HASHCODE(AttrK8sDaemonSetName), "k8s.daemonset.name"}, + // - job + {OTEL_CPP_CONST_HASHCODE(AttrK8sJobUid), "k8s.job.uid"}, + {OTEL_CPP_CONST_HASHCODE(AttrK8sJobName), "k8s.job.name"}, + // - cronjob + {OTEL_CPP_CONST_HASHCODE(AttrCronjobUid), "k8s.cronjob.id"}, + {OTEL_CPP_CONST_HASHCODE(AttrCronjobName), "k8s.cronjob.name"}}; + +// function to generate hash code for semantic conventions attributes. +inline const char *attr(uint32_t attr) +{ + return (attribute_ids.find(attr) != attribute_ids.end()) ? attribute_ids.at(attr) : ""; +} +} // namespace resource +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/resource/resource.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/resource/resource.h new file mode 100644 index 000000000..120e871ab --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/resource/resource.h @@ -0,0 +1,86 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/common/attribute_value.h" +#include "opentelemetry/common/key_value_iterable_view.h" + +#include "opentelemetry/sdk/common/attribute_utils.h" +#include "opentelemetry/sdk/resource/resource_detector.h" +#include "opentelemetry/sdk/version/version.h" +#include "opentelemetry/version.h" + +#include <memory> +#include <sstream> +#include <unordered_map> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace resource +{ + +using ResourceAttributes = opentelemetry::sdk::common::AttributeMap; + +class Resource +{ +public: + Resource(const Resource &) = default; + + const ResourceAttributes &GetAttributes() const noexcept; + const std::string &GetSchemaURL() const noexcept; + + /** + * Returns a new, merged {@link Resource} by merging the current Resource + * with the other Resource. In case of a collision, current Resource takes + * precedence. + * + * @param other the Resource that will be merged with this. + * @returns the newly merged Resource. + */ + + Resource Merge(const Resource &other) noexcept; + + /** + * Returns a newly created Resource with the specified attributes. + * It adds (merge) SDK attributes and OTEL attributes before returning. + * @param attributes for this resource + * @returns the newly created Resource. + */ + + static Resource Create(const ResourceAttributes &attributes, + const std::string &schema_url = std::string{}); + + /** + * Returns an Empty resource. + */ + + static Resource &GetEmpty(); + + /** + * Returns a Resource that indentifies the SDK in use. + */ + + static Resource &GetDefault(); + +protected: + /** + * The constructor is protected and only for use internally by the class and + * inside ResourceDetector class. + * Users should use the Create factory method to obtain a Resource + * instance. + */ + Resource(const ResourceAttributes &attributes = ResourceAttributes(), + const std::string &schema_url = std::string{}) noexcept; + +private: + ResourceAttributes attributes_; + std::string schema_url_; + + friend class OTELResourceDetector; +}; + +} // namespace resource +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/resource/resource_detector.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/resource/resource_detector.h new file mode 100644 index 000000000..5f9d904af --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/resource/resource_detector.h @@ -0,0 +1,38 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/nostd/unique_ptr.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace resource +{ + +class Resource; + +/** + * Interface for a Resource Detector + */ +class ResourceDetector +{ +public: + virtual Resource Detect() = 0; +}; + +/** + * OTelResourceDetector to detect the presence of and create a Resource + * from the OTEL_RESOURCE_ATTRIBUTES environment variable. + */ +class OTELResourceDetector : public ResourceDetector +{ +public: + Resource Detect() noexcept override; +}; + +} // namespace resource +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/batch_span_processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/batch_span_processor.h new file mode 100644 index 000000000..d25ff2d95 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/batch_span_processor.h @@ -0,0 +1,158 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/sdk/common/circular_buffer.h" +#include "opentelemetry/sdk/trace/exporter.h" +#include "opentelemetry/sdk/trace/processor.h" + +#include <atomic> +#include <condition_variable> +#include <thread> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ + +namespace trace +{ + +/** + * Struct to hold batch SpanProcessor options. + */ +struct BatchSpanProcessorOptions +{ + /** + * The maximum buffer/queue size. After the size is reached, spans are + * dropped. + */ + size_t max_queue_size = 2048; + + /* The time interval between two consecutive exports. */ + std::chrono::milliseconds schedule_delay_millis = std::chrono::milliseconds(5000); + + /** + * The maximum batch size of every export. It must be smaller or + * equal to max_queue_size. + */ + size_t max_export_batch_size = 512; +}; + +/** + * This is an implementation of the SpanProcessor which creates batches of finished spans and passes + * the export-friendly span data representations to the configured SpanExporter. + */ +class BatchSpanProcessor : public SpanProcessor +{ +public: + /** + * Creates a batch span processor by configuring the specified exporter and other parameters + * as per the official, language-agnostic opentelemetry specs. + * + * @param exporter - The backend exporter to pass the ended spans to. + * @param options - The batch SpanProcessor options. + */ + BatchSpanProcessor(std::unique_ptr<SpanExporter> &&exporter, + const BatchSpanProcessorOptions &options); + + /** + * Requests a Recordable(Span) from the configured exporter. + * + * @return A recordable generated by the backend exporter + */ + std::unique_ptr<Recordable> MakeRecordable() noexcept override; + + /** + * Called when a span is started. + * + * NOTE: This method is a no-op. + * + * @param span - The span that just started + * @param parent_context - The parent context of the span that just started + */ + void OnStart(Recordable &span, + const opentelemetry::trace::SpanContext &parent_context) noexcept override; + + /** + * Called when a span ends. + * + * @param span - A recordable for a span that just ended + */ + void OnEnd(std::unique_ptr<Recordable> &&span) noexcept override; + + /** + * Export all ended spans that have not been exported yet. + * + * NOTE: Timeout functionality not supported yet. + */ + bool ForceFlush( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override; + + /** + * Shuts down the processor and does any cleanup required. Completely drains the buffer/queue of + * all its ended spans and passes them to the exporter. Any subsequent calls to OnStart, OnEnd, + * ForceFlush or Shutdown will return immediately without doing anything. + * + * NOTE: Timeout functionality not supported yet. + */ + bool Shutdown( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override; + + /** + * Class destructor which invokes the Shutdown() method. The Shutdown() method is supposed to be + * invoked when the Tracer is shutdown (as per other languages), but the C++ Tracer only takes + * shared ownership of the processor, and thus doesn't call Shutdown (as the processor might be + * shared with other Tracers). + */ + ~BatchSpanProcessor(); + +private: + /** + * The background routine performed by the worker thread. + */ + void DoBackgroundWork(); + + /** + * Exports all ended spans to the configured exporter. + * + * @param was_force_flush_called - A flag to check if the current export is the result + * of a call to ForceFlush method. If true, then we have to + * notify the main thread to wake it up in the ForceFlush + * method. + */ + void Export(const bool was_for_flush_called); + + /** + * Called when Shutdown() is invoked. Completely drains the queue of all its ended spans and + * passes them to the exporter. + */ + void DrainQueue(); + + /* The configured backend exporter */ + std::unique_ptr<SpanExporter> exporter_; + + /* Configurable parameters as per the official specs */ + const size_t max_queue_size_; + const std::chrono::milliseconds schedule_delay_millis_; + const size_t max_export_batch_size_; + + /* Synchronization primitives */ + std::condition_variable cv_, force_flush_cv_; + std::mutex cv_m_, force_flush_cv_m_, shutdown_m_; + + /* The buffer/queue to which the ended spans are added */ + common::CircularBuffer<Recordable> buffer_; + + /* Important boolean flags to handle the workflow of the processor */ + std::atomic<bool> is_shutdown_{false}; + std::atomic<bool> is_force_flush_{false}; + std::atomic<bool> is_force_flush_notified_{false}; + + /* The background worker thread */ + std::thread worker_thread_; +}; + +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/exporter.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/exporter.h new file mode 100644 index 000000000..5826b5f45 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/exporter.h @@ -0,0 +1,55 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <memory> +#include "opentelemetry/nostd/span.h" +#include "opentelemetry/sdk/common/exporter_utils.h" +#include "opentelemetry/sdk/trace/recordable.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +/** + * SpanExporter defines the interface that protocol-specific span exporters must + * implement. + */ +class SpanExporter +{ +public: + virtual ~SpanExporter() = default; + + /** + * Create a span recordable. This object will be used to record span data and + * will subsequently be passed to SpanExporter::Export. Vendors can implement + * custom recordables or use the default SpanData recordable provided by the + * SDK. + * @return a newly initialized Recordable object + * + * Note: This method must be callable from multiple threads. + */ + virtual std::unique_ptr<Recordable> MakeRecordable() noexcept = 0; + + /** + * Exports a batch of span recordables. This method must not be called + * concurrently for the same exporter instance. + * @param spans a span of unique pointers to span recordables + */ + virtual sdk::common::ExportResult Export( + const nostd::span<std::unique_ptr<opentelemetry::sdk::trace::Recordable>> + &spans) noexcept = 0; + + /** + * Shut down the exporter. + * @param timeout an optional timeout. + * @return return the status of the operation. + */ + virtual bool Shutdown( + std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept = 0; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/id_generator.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/id_generator.h new file mode 100644 index 000000000..da17effae --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/id_generator.h @@ -0,0 +1,31 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#include "opentelemetry/trace/span_id.h" +#include "opentelemetry/trace/trace_id.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ + +/** IdGenerator provides an interface for generating Trace Id and Span Id */ +class IdGenerator +{ + +public: + virtual ~IdGenerator() = default; + + /** Returns a SpanId represented by opaque 128-bit trace identifier */ + virtual opentelemetry::trace::SpanId GenerateSpanId() noexcept = 0; + + /** Returns a TraceId represented by opaque 64-bit trace identifier */ + virtual opentelemetry::trace::TraceId GenerateTraceId() noexcept = 0; +}; +} // namespace trace + +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/multi_recordable.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/multi_recordable.h new file mode 100644 index 000000000..be97dddc9 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/multi_recordable.h @@ -0,0 +1,161 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/common/timestamp.h" +#include "opentelemetry/sdk/trace/processor.h" +#include "opentelemetry/sdk/trace/recordable.h" +#include "opentelemetry/version.h" + +#include <map> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +namespace +{ +std::size_t MakeKey(const SpanProcessor &processor) +{ + return reinterpret_cast<std::size_t>(&processor); +} + +} // namespace + +class MultiRecordable : public Recordable +{ +public: + void AddRecordable(const SpanProcessor &processor, + std::unique_ptr<Recordable> recordable) noexcept + { + recordables_[MakeKey(processor)] = std::move(recordable); + } + + const std::unique_ptr<Recordable> &GetRecordable(const SpanProcessor &processor) const noexcept + { + // TODO - return nullptr ref on failed lookup? + auto i = recordables_.find(MakeKey(processor)); + if (i != recordables_.end()) + { + return i->second; + } + static std::unique_ptr<Recordable> empty(nullptr); + return empty; + } + + std::unique_ptr<Recordable> ReleaseRecordable(const SpanProcessor &processor) noexcept + { + auto i = recordables_.find(MakeKey(processor)); + if (i != recordables_.end()) + { + std::unique_ptr<Recordable> result(i->second.release()); + recordables_.erase(MakeKey(processor)); + return result; + } + return std::unique_ptr<Recordable>(nullptr); + } + + void SetIdentity(const opentelemetry::trace::SpanContext &span_context, + opentelemetry::trace::SpanId parent_span_id) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->SetIdentity(span_context, parent_span_id); + } + } + + void SetAttribute(nostd::string_view key, + const opentelemetry::common::AttributeValue &value) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->SetAttribute(key, value); + } + } + + void AddEvent(nostd::string_view name, + opentelemetry::common::SystemTimestamp timestamp, + const opentelemetry::common::KeyValueIterable &attributes) noexcept override + { + + for (auto &recordable : recordables_) + { + recordable.second->AddEvent(name, timestamp, attributes); + } + } + + void AddLink(const opentelemetry::trace::SpanContext &span_context, + const opentelemetry::common::KeyValueIterable &attributes) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->AddLink(span_context, attributes); + } + } + + void SetStatus(opentelemetry::trace::StatusCode code, + nostd::string_view description) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->SetStatus(code, description); + } + } + + void SetName(nostd::string_view name) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->SetName(name); + } + } + + void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->SetSpanKind(span_kind); + } + } + + void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->SetResource(resource); + } + } + + void SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->SetStartTime(start_time); + } + } + + void SetDuration(std::chrono::nanoseconds duration) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->SetDuration(duration); + } + } + + void SetInstrumentationLibrary( + const InstrumentationLibrary &instrumentation_library) noexcept override + { + for (auto &recordable : recordables_) + { + recordable.second->SetInstrumentationLibrary(instrumentation_library); + } + } + +private: + std::map<std::size_t, std::unique_ptr<Recordable>> recordables_; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/multi_span_processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/multi_span_processor.h new file mode 100644 index 000000000..8463ad520 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/multi_span_processor.h @@ -0,0 +1,187 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <mutex> +#include <vector> + +#include "opentelemetry/sdk/trace/multi_recordable.h" +#include "opentelemetry/sdk/trace/processor.h" + +#include <iostream> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ + +/** Instantiation options. */ +struct MultiSpanProcessorOptions +{}; + +/** + * Span processor allow hooks for span start and end method invocations. + * + * Built-in span processors are responsible for batching and conversion of + * spans to exportable representation and passing batches to exporters. + */ +class MultiSpanProcessor : public SpanProcessor +{ +public: + MultiSpanProcessor(std::vector<std::unique_ptr<SpanProcessor>> &&processors) + : head_(nullptr), tail_(nullptr), count_(0) + { + for (auto &processor : processors) + { + AddProcessor(std::move(processor)); + } + } + + void AddProcessor(std::unique_ptr<SpanProcessor> &&processor) + { + // Add preocessor to end of the list. + if (processor) + { + ProcessorNode *pNode = new ProcessorNode(std::move(processor), tail_); + if (count_ > 0) + { + tail_->next_ = pNode; + tail_ = pNode; + } + else + { + head_ = tail_ = pNode; + } + count_++; + } + } + + std::unique_ptr<Recordable> MakeRecordable() noexcept override + { + auto recordable = std::unique_ptr<Recordable>(new MultiRecordable); + auto multi_recordable = static_cast<MultiRecordable *>(recordable.get()); + ProcessorNode *node = head_; + while (node != nullptr) + { + auto processor = node->value_.get(); + multi_recordable->AddRecordable(*processor, processor->MakeRecordable()); + node = node->next_; + } + return recordable; + } + + virtual void OnStart(Recordable &span, + const opentelemetry::trace::SpanContext &parent_context) noexcept override + { + auto multi_recordable = static_cast<MultiRecordable *>(&span); + ProcessorNode *node = head_; + while (node != nullptr) + { + auto processor = node->value_.get(); + auto &recordable = multi_recordable->GetRecordable(*processor); + if (recordable != nullptr) + { + processor->OnStart(*recordable, parent_context); + } + node = node->next_; + } + } + + virtual void OnEnd(std::unique_ptr<Recordable> &&span) noexcept override + { + auto multi_recordable = static_cast<MultiRecordable *>(span.release()); + ProcessorNode *node = head_; + while (node != nullptr) + { + auto processor = node->value_.get(); + auto recordable = multi_recordable->ReleaseRecordable(*processor); + if (recordable != nullptr) + { + processor->OnEnd(std::move(recordable)); + } + node = node->next_; + } + delete multi_recordable; + } + + bool ForceFlush( + std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override + { + bool result = true; + ProcessorNode *node = head_; + while (node != nullptr) + { + auto processor = node->value_.get(); + result |= processor->ForceFlush(timeout); + node = node->next_; + } + return result; + } + + bool Shutdown( + std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override + { + bool result = true; + ProcessorNode *node = head_; + while (node != nullptr) + { + auto processor = node->value_.get(); + result |= processor->Shutdown(timeout); + node = node->next_; + } + return result; + } + + ~MultiSpanProcessor() + { + Shutdown(); + Cleanup(); + } + +private: + struct ProcessorNode + { + std::unique_ptr<SpanProcessor> value_; + ProcessorNode *next_, *prev_; + ProcessorNode(std::unique_ptr<SpanProcessor> &&value, + ProcessorNode *prev = nullptr, + ProcessorNode *next = nullptr) + : value_(std::move(value)), next_(next), prev_(prev) + {} + }; + + void Cleanup() + { + if (count_) + { + ProcessorNode *node = tail_; + while (node != nullptr) + { + if (node->next_ != nullptr) + { + delete node->next_; + node->next_ = nullptr; + } + if (node->prev_ != nullptr) + { + node = node->prev_; + } + else + { + delete node; + node = nullptr; + } + } + head_ = tail_ = nullptr; + count_ = 0; + } + } + + ProcessorNode *head_, *tail_; + size_t count_; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/processor.h new file mode 100644 index 000000000..17ac0e59a --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/processor.h @@ -0,0 +1,70 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <chrono> +#include <memory> +#include "opentelemetry/sdk/trace/recordable.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +/** + * Span processor allow hooks for span start and end method invocations. + * + * Built-in span processors are responsible for batching and conversion of + * spans to exportable representation and passing batches to exporters. + */ +class SpanProcessor +{ +public: + virtual ~SpanProcessor() = default; + + /** + * Create a span recordable. This requests a new span recordable from the + * associated exporter. + * @return a newly initialized recordable + * + * Note: This method must be callable from multiple threads. + */ + virtual std::unique_ptr<Recordable> MakeRecordable() noexcept = 0; + + /** + * OnStart is called when a span is started. + * @param span a recordable for a span that was just started + * @param parent_context The parent context of the span that just started + */ + virtual void OnStart(Recordable &span, + const opentelemetry::trace::SpanContext &parent_context) noexcept = 0; + + /** + * OnEnd is called when a span is ended. + * @param span a recordable for a span that was ended + */ + virtual void OnEnd(std::unique_ptr<Recordable> &&span) noexcept = 0; + + /** + * Export all ended spans that have not yet been exported. + * @param timeout an optional timeout, the default timeout of 0 means that no + * timeout is applied. + */ + virtual bool ForceFlush( + std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept = 0; + + /** + * Shut down the processor and do any cleanup required. Ended spans are + * exported before shutdown. After the call to Shutdown, subsequent calls to + * OnStart, OnEnd, ForceFlush or Shutdown will return immediately without + * doing anything. + * @param timeout an optional timeout, the default timeout of 0 means that no + * timeout is applied. + */ + virtual bool Shutdown( + std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept = 0; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/random_id_generator.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/random_id_generator.h new file mode 100644 index 000000000..908f1b850 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/random_id_generator.h @@ -0,0 +1,24 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once +#include "opentelemetry/sdk/trace/id_generator.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ + +class RandomIdGenerator : public IdGenerator +{ +public: + opentelemetry::trace::SpanId GenerateSpanId() noexcept override; + + opentelemetry::trace::TraceId GenerateTraceId() noexcept override; +}; + +} // namespace trace + +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE
\ No newline at end of file diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/recordable.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/recordable.h new file mode 100644 index 000000000..b92a3ff06 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/recordable.h @@ -0,0 +1,152 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/common/attribute_value.h" +#include "opentelemetry/common/key_value_iterable.h" +#include "opentelemetry/common/timestamp.h" +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/sdk/common/empty_attributes.h" +#include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h" +#include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/trace/canonical_code.h" +#include "opentelemetry/trace/span.h" +#include "opentelemetry/trace/span_context.h" +#include "opentelemetry/trace/span_id.h" +#include "opentelemetry/trace/trace_id.h" +#include "opentelemetry/version.h" + +#include <map> + +// TODO: Create generic short pattern for opentelemetry::common and opentelemetry::trace + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ + +using namespace opentelemetry::sdk::instrumentationlibrary; + +/** + * Maintains a representation of a span in a format that can be processed by a recorder. + * + * This class is thread-compatible. + */ +class Recordable +{ +public: + virtual ~Recordable() = default; + + /** + * Set the span context and parent span id + * @param span_context the span context to set + * @param parent_span_id the parent span id to set + */ + virtual void SetIdentity(const opentelemetry::trace::SpanContext &span_context, + opentelemetry::trace::SpanId parent_span_id) noexcept = 0; + + /** + * Set an attribute of a span. + * @param name the name of the attribute + * @param value the attribute value + */ + virtual void SetAttribute(nostd::string_view key, + const opentelemetry::common::AttributeValue &value) noexcept = 0; + + /** + * Add an event to a span. + * @param name the name of the event + * @param timestamp the timestamp of the event + * @param attributes the attributes associated with the event + */ + virtual void AddEvent(nostd::string_view name, + opentelemetry::common::SystemTimestamp timestamp, + const opentelemetry::common::KeyValueIterable &attributes) noexcept = 0; + + /** + * Add an event to a span with default timestamp and attributes. + * @param name the name of the event + */ + void AddEvent(nostd::string_view name) + { + AddEvent(name, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now()), + opentelemetry::sdk::GetEmptyAttributes()); + } + + /** + * Add an event to a span with default (empty) attributes. + * @param name the name of the event + * @param timestamp the timestamp of the event + */ + void AddEvent(nostd::string_view name, opentelemetry::common::SystemTimestamp timestamp) + { + AddEvent(name, timestamp, opentelemetry::sdk::GetEmptyAttributes()); + } + + /** + * Add a link to a span. + * @param span_context the span context of the linked span + * @param attributes the attributes associated with the link + */ + virtual void AddLink(const opentelemetry::trace::SpanContext &span_context, + const opentelemetry::common::KeyValueIterable &attributes) noexcept = 0; + + /** + * Add a link to a span with default (empty) attributes. + * @param span_context the span context of the linked span + */ + void AddLink(opentelemetry::trace::SpanContext span_context) + { + AddLink(span_context, opentelemetry::sdk::GetEmptyAttributes()); + } + + /** + * Set the status of the span. + * @param code the status code + * @param description a description of the status + */ + virtual void SetStatus(opentelemetry::trace::StatusCode code, + nostd::string_view description) noexcept = 0; + + /** + * Set the name of the span. + * @param name the name to set + */ + virtual void SetName(nostd::string_view name) noexcept = 0; + + /** + * Set the spankind of the span. + * @param span_kind the spankind to set + */ + virtual void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept = 0; + + /** + * Set Resource of the span + * @param Resource the resource to set + */ + virtual void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept = 0; + + /** + * Set the start time of the span. + * @param start_time the start time to set + */ + virtual void SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept = 0; + + /** + * Set the duration of the span. + * @param duration the duration to set + */ + virtual void SetDuration(std::chrono::nanoseconds duration) noexcept = 0; + + /** + * Set the instrumentation library of the span. + * @param instrumentation_library the instrumentation library to set + */ + virtual void SetInstrumentationLibrary( + const InstrumentationLibrary &instrumentation_library) noexcept = 0; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/sampler.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/sampler.h new file mode 100644 index 000000000..452ba924b --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/sampler.h @@ -0,0 +1,91 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/common/attribute_value.h" +#include "opentelemetry/trace/span.h" +#include "opentelemetry/trace/span_context.h" +#include "opentelemetry/trace/span_context_kv_iterable.h" +#include "opentelemetry/trace/trace_id.h" +#include "opentelemetry/trace/trace_state.h" +#include "opentelemetry/version.h" + +#include <map> +#include <memory> +#include <string> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +/** + * A sampling Decision for a Span to be created. + */ +enum class Decision +{ + // IsRecording() == false, span will not be recorded and all events and attributes will be + // dropped. + DROP, + // IsRecording() == true, but Sampled flag MUST NOT be set. + RECORD_ONLY, + // IsRecording() == true AND Sampled flag` MUST be set. + RECORD_AND_SAMPLE +}; + +/** + * The output of ShouldSample. + * It contains a sampling Decision and a set of Span Attributes. + */ +struct SamplingResult +{ + Decision decision; + // A set of span Attributes that will also be added to the Span. Can be nullptr. + std::unique_ptr<const std::map<std::string, opentelemetry::common::AttributeValue>> attributes; + // The tracestate used by the span. + nostd::shared_ptr<opentelemetry::trace::TraceState> trace_state; +}; + +/** + * The Sampler interface allows users to create custom samplers which will return a + * SamplingResult based on information that is typically available just before the Span was created. + */ +class Sampler +{ +public: + virtual ~Sampler() = default; + /** + * Called during Span creation to make a sampling decision. + * + * @param parent_context a const reference to the SpanContext of a parent Span. + * An invalid SpanContext if this is a root span. + * @param trace_id the TraceId for the new Span. This will be identical to that in + * the parentContext, unless this is a root span. + * @param name the name of the new Span. + * @param spanKind the opentelemetry::trace::SpanKind of the Span. + * @param attributes list of AttributeValue with their keys. + * @param links Collection of links that will be associated with the Span to be created. + * @return sampling result whether span should be sampled or not. + * @since 0.1.0 + */ + + virtual SamplingResult ShouldSample( + const opentelemetry::trace::SpanContext &parent_context, + opentelemetry::trace::TraceId trace_id, + nostd::string_view name, + opentelemetry::trace::SpanKind span_kind, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::trace::SpanContextKeyValueIterable &links) noexcept = 0; + + /** + * Returns the sampler name or short description with the configuration. + * This may be displayed on debug pages or in the logs. + * + * @return the description of this Sampler. + */ + virtual nostd::string_view GetDescription() const noexcept = 0; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/always_off.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/always_off.h new file mode 100644 index 000000000..2392b9b2f --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/always_off.h @@ -0,0 +1,48 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/sdk/trace/sampler.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +/** + * The always off sampler always returns DROP, effectively disabling + * tracing functionality. + */ +class AlwaysOffSampler : public Sampler +{ +public: + /** + * @return Returns DROP always + */ + SamplingResult ShouldSample( + const opentelemetry::trace::SpanContext &parent_context, + opentelemetry::trace::TraceId /*trace_id*/, + nostd::string_view /*name*/, + opentelemetry::trace::SpanKind /*span_kind*/, + const opentelemetry::common::KeyValueIterable & /*attributes*/, + const opentelemetry::trace::SpanContextKeyValueIterable & /*links*/) noexcept override + { + if (!parent_context.IsValid()) + { + return {Decision::DROP, nullptr, opentelemetry::trace::TraceState::GetDefault()}; + } + else + { + return {Decision::DROP, nullptr, parent_context.trace_state()}; + } + } + + /** + * @return Description MUST be AlwaysOffSampler + */ + nostd::string_view GetDescription() const noexcept override { return "AlwaysOffSampler"; } +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/always_on.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/always_on.h new file mode 100644 index 000000000..6c8583599 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/always_on.h @@ -0,0 +1,47 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/sdk/trace/sampler.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +/** + * The always on sampler is a default sampler which always return Decision::RECORD_AND_SAMPLE + */ +class AlwaysOnSampler : public Sampler +{ +public: + /** + * @return Always return Decision RECORD_AND_SAMPLE + */ + inline SamplingResult ShouldSample( + const opentelemetry::trace::SpanContext &parent_context, + opentelemetry::trace::TraceId /*trace_id*/, + nostd::string_view /*name*/, + opentelemetry::trace::SpanKind /*span_kind*/, + const opentelemetry::common::KeyValueIterable & /*attributes*/, + const opentelemetry::trace::SpanContextKeyValueIterable & /*links*/) noexcept override + { + if (!parent_context.IsValid()) + { + return {Decision::RECORD_AND_SAMPLE, nullptr, opentelemetry::trace::TraceState::GetDefault()}; + } + else + { + return {Decision::RECORD_AND_SAMPLE, nullptr, parent_context.trace_state()}; + } + } + + /** + * @return Description MUST be AlwaysOnSampler + */ + inline nostd::string_view GetDescription() const noexcept override { return "AlwaysOnSampler"; } +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/parent.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/parent.h new file mode 100644 index 000000000..c76a6c2a5 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/parent.h @@ -0,0 +1,45 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/sdk/common/atomic_shared_ptr.h" +#include "opentelemetry/sdk/trace/sampler.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +/** + * The ParentBased sampler is a composite sampler. ParentBased(delegateSampler) either respects + * the parent span's sampling decision or delegates to delegateSampler for root spans. + */ +class ParentBasedSampler : public Sampler +{ +public: + explicit ParentBasedSampler(std::shared_ptr<Sampler> delegate_sampler) noexcept; + /** The decision either respects the parent span's sampling decision or delegates to + * delegateSampler for root spans + * @return Returns DROP always + */ + SamplingResult ShouldSample( + const opentelemetry::trace::SpanContext &parent_context, + opentelemetry::trace::TraceId trace_id, + nostd::string_view name, + opentelemetry::trace::SpanKind span_kind, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::trace::SpanContextKeyValueIterable &links) noexcept override; + + /** + * @return Description MUST be ParentBased{delegate_sampler_.getDescription()} + */ + nostd::string_view GetDescription() const noexcept override; + +private: + const std::shared_ptr<Sampler> delegate_sampler_; + const std::string description_; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/trace_id_ratio.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/trace_id_ratio.h new file mode 100644 index 000000000..407b480d6 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/samplers/trace_id_ratio.h @@ -0,0 +1,53 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/sdk/trace/sampler.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +/** + * The TraceIdRatioBased sampler computes and returns a decision based on the + * provided trace_id and the configured ratio. + */ +class TraceIdRatioBasedSampler : public Sampler +{ +public: + /** + * @param ratio a required value, 1.0 >= ratio >= 0.0. If the given trace_id + * falls into a given ratio of all possible trace_id values, ShouldSample will + * return RECORD_AND_SAMPLE. + * @throws invalid_argument if ratio is out of bounds [0.0, 1.0] + */ + explicit TraceIdRatioBasedSampler(double ratio); + + /** + * @return Returns either RECORD_AND_SAMPLE or DROP based on current + * sampler configuration and provided trace_id and ratio. trace_id + * is used as a pseudorandom value in conjunction with the predefined + * ratio to determine whether this trace should be sampled + */ + SamplingResult ShouldSample( + const opentelemetry::trace::SpanContext & /*parent_context*/, + opentelemetry::trace::TraceId trace_id, + nostd::string_view /*name*/, + opentelemetry::trace::SpanKind /*span_kind*/, + const opentelemetry::common::KeyValueIterable & /*attributes*/, + const opentelemetry::trace::SpanContextKeyValueIterable & /*links*/) noexcept override; + + /** + * @return Description MUST be TraceIdRatioBasedSampler{0.000100} + */ + nostd::string_view GetDescription() const noexcept override; + +private: + std::string description_; + const uint64_t threshold_; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/simple_processor.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/simple_processor.h new file mode 100644 index 000000000..accc68596 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/simple_processor.h @@ -0,0 +1,84 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <atomic> +#include <mutex> + +#include "opentelemetry/common/spin_lock_mutex.h" +#include "opentelemetry/sdk/trace/exporter.h" +#include "opentelemetry/sdk/trace/processor.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +/** + * The simple span processor passes finished recordables to the configured + * SpanExporter, as soon as they are finished. + * + * OnEnd and ForceFlush are no-ops. + * + * All calls to the configured SpanExporter are synchronized using a + * spin-lock on an atomic_flag. + */ +class SimpleSpanProcessor : public SpanProcessor +{ +public: + /** + * Initialize a simple span processor. + * @param exporter the exporter used by the span processor + */ + explicit SimpleSpanProcessor(std::unique_ptr<SpanExporter> &&exporter) noexcept + : exporter_(std::move(exporter)) + {} + + std::unique_ptr<Recordable> MakeRecordable() noexcept override + { + return exporter_->MakeRecordable(); + } + + void OnStart(Recordable &span, + const opentelemetry::trace::SpanContext &parent_context) noexcept override + {} + + void OnEnd(std::unique_ptr<Recordable> &&span) noexcept override + { + nostd::span<std::unique_ptr<Recordable>> batch(&span, 1); + const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_); + if (exporter_->Export(batch) == sdk::common::ExportResult::kFailure) + { + /* Once it is defined how the SDK does logging, an error should be + * logged in this case. */ + } + } + + bool ForceFlush( + std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override + { + return true; + } + + bool Shutdown( + std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override + { + // We only call shutdown ONCE. + if (exporter_ != nullptr && !shutdown_latch_.test_and_set(std::memory_order_acquire)) + { + return exporter_->Shutdown(timeout); + } + return true; + } + + ~SimpleSpanProcessor() { Shutdown(); } + +private: + std::unique_ptr<SpanExporter> exporter_; + opentelemetry::common::SpinLockMutex lock_; + std::atomic_flag shutdown_latch_ = ATOMIC_FLAG_INIT; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/span_data.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/span_data.h new file mode 100644 index 000000000..0fb09f328 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/span_data.h @@ -0,0 +1,304 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <chrono> +#include <unordered_map> +#include <vector> +#include "opentelemetry/common/attribute_value.h" +#include "opentelemetry/common/timestamp.h" +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/sdk/common/attribute_utils.h" +#include "opentelemetry/sdk/trace/recordable.h" +#include "opentelemetry/trace/canonical_code.h" +#include "opentelemetry/trace/span.h" +#include "opentelemetry/trace/span_id.h" +#include "opentelemetry/trace/trace_id.h" + +#include <string> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +/** + * Class for storing events in SpanData. + */ +class SpanDataEvent +{ +public: + SpanDataEvent(std::string name, + opentelemetry::common::SystemTimestamp timestamp, + const opentelemetry::common::KeyValueIterable &attributes) + : name_(name), timestamp_(timestamp), attribute_map_(attributes) + {} + + /** + * Get the name for this event + * @return the name for this event + */ + std::string GetName() const noexcept { return name_; } + + /** + * Get the timestamp for this event + * @return the timestamp for this event + */ + opentelemetry::common::SystemTimestamp GetTimestamp() const noexcept { return timestamp_; } + + /** + * Get the attributes for this event + * @return the attributes for this event + */ + const std::unordered_map<std::string, common::OwnedAttributeValue> &GetAttributes() const noexcept + { + return attribute_map_.GetAttributes(); + } + +private: + std::string name_; + opentelemetry::common::SystemTimestamp timestamp_; + common::AttributeMap attribute_map_; +}; + +/** + * Class for storing links in SpanData. + */ +class SpanDataLink +{ +public: + SpanDataLink(opentelemetry::trace::SpanContext span_context, + const opentelemetry::common::KeyValueIterable &attributes) + : span_context_(span_context), attribute_map_(attributes) + {} + + /** + * Get the attributes for this link + * @return the attributes for this link + */ + const std::unordered_map<std::string, common::OwnedAttributeValue> &GetAttributes() const noexcept + { + return attribute_map_.GetAttributes(); + } + + /** + * Get the span context for this link + * @return the span context for this link + */ + const opentelemetry::trace::SpanContext &GetSpanContext() const noexcept { return span_context_; } + +private: + opentelemetry::trace::SpanContext span_context_; + common::AttributeMap attribute_map_; +}; + +/** + * SpanData is a representation of all data collected by a span. + */ +class SpanData final : public Recordable +{ +public: + SpanData() : resource_{nullptr}, instrumentation_library_{nullptr} {} + /** + * Get the trace id for this span + * @return the trace id for this span + */ + opentelemetry::trace::TraceId GetTraceId() const noexcept { return span_context_.trace_id(); } + + /** + * Get the span id for this span + * @return the span id for this span + */ + opentelemetry::trace::SpanId GetSpanId() const noexcept { return span_context_.span_id(); } + + /** + * Get the span context for this span + * @return the span context for this span + */ + const opentelemetry::trace::SpanContext &GetSpanContext() const noexcept { return span_context_; } + + /** + * Get the parent span id for this span + * @return the span id for this span's parent + */ + opentelemetry::trace::SpanId GetParentSpanId() const noexcept { return parent_span_id_; } + + /** + * Get the name for this span + * @return the name for this span + */ + opentelemetry::nostd::string_view GetName() const noexcept { return name_; } + + /** + * Get the kind of this span + * @return the kind of this span + */ + opentelemetry::trace::SpanKind GetSpanKind() const noexcept { return span_kind_; } + + /** + * Get the status for this span + * @return the status for this span + */ + opentelemetry::trace::StatusCode GetStatus() const noexcept { return status_code_; } + + /** + * Get the status description for this span + * @return the description of the the status of this span + */ + opentelemetry::nostd::string_view GetDescription() const noexcept { return status_desc_; } + + /** + * Get the attributes associated with the resource + * @returns the attributes associated with the resource configured for TracerProvider + */ + + const opentelemetry::sdk::resource::Resource &GetResource() const noexcept + { + if (resource_ == nullptr) + { + // this shouldn't happen as TraceProvider provides default resources + static opentelemetry::sdk::resource::Resource resource = + opentelemetry::sdk::resource::Resource::GetEmpty(); + return resource; + } + return *resource_; + } + + /** + * Get the attributes associated with the resource + * @returns the attributes associated with the resource configured for TracerProvider + */ + + const opentelemetry::sdk::trace::InstrumentationLibrary &GetInstrumentationLibrary() + const noexcept + { + if (instrumentation_library_ == nullptr) + { + // this shouldn't happen as Tracer ensures there is valid default instrumentation library. + static std::unique_ptr<opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary> + instrumentation_library = + opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary::Create( + "unknown_service"); + return *instrumentation_library; + } + return *instrumentation_library_; + } + + /** + * Get the start time for this span + * @return the start time for this span + */ + opentelemetry::common::SystemTimestamp GetStartTime() const noexcept { return start_time_; } + + /** + * Get the duration for this span + * @return the duration for this span + */ + std::chrono::nanoseconds GetDuration() const noexcept { return duration_; } + + /** + * Get the attributes for this span + * @return the attributes for this span + */ + const std::unordered_map<std::string, common::OwnedAttributeValue> &GetAttributes() const noexcept + { + return attribute_map_.GetAttributes(); + } + + /** + * Get the events associated with this span + * @return the events associated with this span + */ + const std::vector<SpanDataEvent> &GetEvents() const noexcept { return events_; } + + /** + * Get the links associated with this span + * @return the links associated with this span + */ + const std::vector<SpanDataLink> &GetLinks() const noexcept { return links_; } + + void SetIdentity(const opentelemetry::trace::SpanContext &span_context, + opentelemetry::trace::SpanId parent_span_id) noexcept override + { + span_context_ = span_context; + parent_span_id_ = parent_span_id; + } + + void SetAttribute(nostd::string_view key, + const opentelemetry::common::AttributeValue &value) noexcept override + { + attribute_map_.SetAttribute(key, value); + } + + void AddEvent(nostd::string_view name, + opentelemetry::common::SystemTimestamp timestamp = + opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now()), + const opentelemetry::common::KeyValueIterable &attributes = + opentelemetry::common::KeyValueIterableView<std::map<std::string, int>>( + {})) noexcept override + { + SpanDataEvent event(std::string(name), timestamp, attributes); + events_.push_back(event); + } + + void AddLink(const opentelemetry::trace::SpanContext &span_context, + const opentelemetry::common::KeyValueIterable &attributes) noexcept override + { + SpanDataLink link(span_context, attributes); + links_.push_back(link); + } + + void SetStatus(opentelemetry::trace::StatusCode code, + nostd::string_view description) noexcept override + { + status_code_ = code; + status_desc_ = std::string(description); + } + + void SetName(nostd::string_view name) noexcept override + { + name_ = std::string(name.data(), name.length()); + } + + void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept override + { + span_kind_ = span_kind; + } + + void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override + { + resource_ = &resource; + } + + void SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept override + { + start_time_ = start_time; + } + + void SetDuration(std::chrono::nanoseconds duration) noexcept override { duration_ = duration; } + + void SetInstrumentationLibrary( + const InstrumentationLibrary &instrumentation_library) noexcept override + { + instrumentation_library_ = &instrumentation_library; + } + +private: + opentelemetry::trace::SpanContext span_context_{false, false}; + opentelemetry::trace::SpanId parent_span_id_; + opentelemetry::common::SystemTimestamp start_time_; + std::chrono::nanoseconds duration_{0}; + std::string name_; + opentelemetry::trace::StatusCode status_code_{opentelemetry::trace::StatusCode::kUnset}; + std::string status_desc_; + common::AttributeMap attribute_map_; + std::vector<SpanDataEvent> events_; + std::vector<SpanDataLink> links_; + opentelemetry::trace::SpanKind span_kind_{opentelemetry::trace::SpanKind::kInternal}; + const opentelemetry::sdk::resource::Resource *resource_; + const InstrumentationLibrary *instrumentation_library_; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/tracer.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/tracer.h new file mode 100644 index 000000000..fd9f2c8e8 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/tracer.h @@ -0,0 +1,70 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/sdk/common/atomic_shared_ptr.h" +#include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h" +#include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/sdk/trace/processor.h" +#include "opentelemetry/sdk/trace/samplers/always_on.h" +#include "opentelemetry/sdk/trace/tracer_context.h" +#include "opentelemetry/trace/noop.h" +#include "opentelemetry/trace/tracer.h" +#include "opentelemetry/version.h" + +#include <memory> + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ + +using namespace opentelemetry::sdk::instrumentationlibrary; + +class Tracer final : public trace_api::Tracer, public std::enable_shared_from_this<Tracer> +{ +public: + /** Construct a new Tracer with the given context pipeline. */ + explicit Tracer(std::shared_ptr<sdk::trace::TracerContext> context, + std::unique_ptr<InstrumentationLibrary> instrumentation_library = + InstrumentationLibrary::Create("")) noexcept; + + nostd::shared_ptr<trace_api::Span> StartSpan( + nostd::string_view name, + const opentelemetry::common::KeyValueIterable &attributes, + const trace_api::SpanContextKeyValueIterable &links, + const trace_api::StartSpanOptions &options = {}) noexcept override; + + void ForceFlushWithMicroseconds(uint64_t timeout) noexcept override; + + void CloseWithMicroseconds(uint64_t timeout) noexcept override; + + /** Returns the configured span processor. */ + SpanProcessor &GetProcessor() noexcept { return context_->GetProcessor(); } + + /** Returns the configured Id generator */ + IdGenerator &GetIdGenerator() const noexcept { return context_->GetIdGenerator(); } + + /** Returns the associated instruementation library */ + const InstrumentationLibrary &GetInstrumentationLibrary() const noexcept + { + return *instrumentation_library_; + } + + /** Returns the currently configured resource **/ + const opentelemetry::sdk::resource::Resource &GetResource() { return context_->GetResource(); } + + // Note: Test only + Sampler &GetSampler() { return context_->GetSampler(); } + +private: + // order of declaration is important here - instrumentation library should destroy after + // tracer-context. + std::shared_ptr<InstrumentationLibrary> instrumentation_library_; + std::shared_ptr<sdk::trace::TracerContext> context_; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/tracer_context.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/tracer_context.h new file mode 100644 index 000000000..572f60caf --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/tracer_context.h @@ -0,0 +1,100 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/sdk/common/atomic_unique_ptr.h" +#include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/sdk/trace/processor.h" +#include "opentelemetry/sdk/trace/random_id_generator.h" +#include "opentelemetry/sdk/trace/samplers/always_on.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ + +/** + * A class which stores the TracerProvider context. + * + * This class meets the following design criteria: + * - A shared reference between TracerProvider and Tracers instantiated. + * - A thread-safe class that allows updating/altering processor/exporter pipelines + * and sampling config. + * - The owner/destroyer of Processors/Exporters. These will remain active until + * this class is destroyed. I.e. Sampling, Exporting, flushing, Custom Iterator etc. are all ok + * if this object is alive, and they will work together. If this object is destroyed, then no shared + * references to Processor, Exporter, Recordable, Custom Iterator etc. should exist, and all + * associated pipelines will have been flushed. + */ +class TracerContext +{ +public: + explicit TracerContext( + std::vector<std::unique_ptr<SpanProcessor>> &&processor, + opentelemetry::sdk::resource::Resource resource = + opentelemetry::sdk::resource::Resource::Create({}), + std::unique_ptr<Sampler> sampler = std::unique_ptr<AlwaysOnSampler>(new AlwaysOnSampler), + std::unique_ptr<IdGenerator> id_generator = + std::unique_ptr<IdGenerator>(new RandomIdGenerator())) noexcept; + + /** + * Attaches a span processor to list of configured processors to this tracer context. + * Processor once attached can't be removed. + * @param processor The new span processor for this tracer. This must not be + * a nullptr. Ownership is given to the `TracerContext`. + * + * Note: This method is not thread safe. + */ + void AddProcessor(std::unique_ptr<SpanProcessor> processor) noexcept; + + /** + * Obtain the sampler associated with this tracer. + * @return The sampler for this tracer. + */ + Sampler &GetSampler() const noexcept; + + /** + * Obtain the configured (composite) processor. + * + * Note: When more than one processor is active, this will + * return an "aggregate" processor + */ + SpanProcessor &GetProcessor() const noexcept; + + /** + * Obtain the resource associated with this tracer context. + * @return The resource for this tracer context. + */ + const opentelemetry::sdk::resource::Resource &GetResource() const noexcept; + + /** + * Obtain the Id Generator associated with this tracer context. + * @return The ID Generator for this tracer context. + */ + opentelemetry::sdk::trace::IdGenerator &GetIdGenerator() const noexcept; + + /** + * Force all active SpanProcessors to flush any buffered spans + * within the given timeout. + */ + bool ForceFlush(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept; + + /** + * Shutdown the span processor associated with this tracer provider. + */ + bool Shutdown() noexcept; + +private: + // order of declaration is important here - resource object should be destroyed after processor. + opentelemetry::sdk::resource::Resource resource_; + std::unique_ptr<Sampler> sampler_; + std::unique_ptr<IdGenerator> id_generator_; + std::unique_ptr<SpanProcessor> processor_; +}; + +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/tracer_provider.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/tracer_provider.h new file mode 100644 index 000000000..aa0f69a2b --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/trace/tracer_provider.h @@ -0,0 +1,103 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include <map> +#include <memory> +#include <mutex> +#include <string> +#include <vector> + +#include "opentelemetry/nostd/shared_ptr.h" +#include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/sdk/trace/processor.h" +#include "opentelemetry/sdk/trace/samplers/always_on.h" +#include "opentelemetry/sdk/trace/tracer.h" +#include "opentelemetry/sdk/trace/tracer_context.h" +#include "opentelemetry/trace/tracer_provider.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace trace +{ +class TracerProvider final : public opentelemetry::trace::TracerProvider +{ +public: + /** + * Initialize a new tracer provider with a specified sampler + * @param processor The span processor for this tracer provider. This must + * not be a nullptr. + * @param resource The resources for this tracer provider. + * @param sampler The sampler for this tracer provider. This must + * not be a nullptr. + * @param id_generator The custom id generator for this tracer provider. This must + * not be a nullptr + */ + explicit TracerProvider( + std::unique_ptr<SpanProcessor> processor, + opentelemetry::sdk::resource::Resource resource = + opentelemetry::sdk::resource::Resource::Create({}), + std::unique_ptr<Sampler> sampler = std::unique_ptr<AlwaysOnSampler>(new AlwaysOnSampler), + std::unique_ptr<opentelemetry::sdk::trace::IdGenerator> id_generator = + std::unique_ptr<opentelemetry::sdk::trace::IdGenerator>( + new RandomIdGenerator())) noexcept; + + explicit TracerProvider( + std::vector<std::unique_ptr<SpanProcessor>> &&processors, + opentelemetry::sdk::resource::Resource resource = + opentelemetry::sdk::resource::Resource::Create({}), + std::unique_ptr<Sampler> sampler = std::unique_ptr<AlwaysOnSampler>(new AlwaysOnSampler), + std::unique_ptr<opentelemetry::sdk::trace::IdGenerator> id_generator = + std::unique_ptr<opentelemetry::sdk::trace::IdGenerator>( + new RandomIdGenerator())) noexcept; + + /** + * Initialize a new tracer provider with a specified context + * @param context The shared tracer configuration/pipeline for this provider. + */ + explicit TracerProvider(std::shared_ptr<sdk::trace::TracerContext> context) noexcept; + + ~TracerProvider(); + + opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer> GetTracer( + nostd::string_view library_name, + nostd::string_view library_version = "", + nostd::string_view schema_url = "") noexcept override; + + /** + * Attaches a span processor to list of configured processors for this tracer provider. + * @param processor The new span processor for this tracer provider. This + * must not be a nullptr. + * + * Note: This process may not receive any in-flight spans, but will get newly created spans. + * Note: This method is not thread safe, and should ideally be called from main thread. + */ + void AddProcessor(std::unique_ptr<SpanProcessor> processor) noexcept; + + /** + * Obtain the resource associated with this tracer provider. + * @return The resource for this tracer provider. + */ + const opentelemetry::sdk::resource::Resource &GetResource() const noexcept; + + /** + * Shutdown the span processor associated with this tracer provider. + */ + bool Shutdown() noexcept; + + /** + * Force flush the span processor associated with this tracer provider. + */ + bool ForceFlush(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept; + +private: + // order of declaration is important here - tracers should destroy only after context. + std::vector<std::shared_ptr<opentelemetry::sdk::trace::Tracer>> tracers_; + std::shared_ptr<sdk::trace::TracerContext> context_; + std::mutex lock_; +}; +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/version/version.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/version/version.h new file mode 100644 index 000000000..65c3c826c --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk/version/version.h @@ -0,0 +1,30 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/detail/preprocessor.h" + +#define OPENTELEMETRY_SDK_VERSION "1.4.0" + +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace version +{ +extern const int MAJOR_VERSION; +extern const int MINOR_VERSION; +extern const int PATCH_VERSION; +extern const char *PRE_RELEASE; +extern const char *BUILD_METADATA; +extern const int COUNT_NEW_COMMITS; +extern const char *BRANCH; +extern const char *COMMIT_HASH; +extern const char *FULL_VERSION; +extern const char *FULL_VERSION_WITH_BRANCH_COMMITHASH; +extern const char *BUILD_DATE; +} // namespace version +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk_config.h b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk_config.h new file mode 100644 index 000000000..8ac72a10d --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/include/opentelemetry/sdk_config.h @@ -0,0 +1,7 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/config.h" +#include "opentelemetry/sdk/common/global_log_handler.h"
\ No newline at end of file |