From cdd7ad020e165fe680703b6d3319b908b682fb7a Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Fri, 20 Oct 2023 17:12:29 +0300 Subject: jaeger-client -> opentelemetry --- .../Metrics/Experimental/MetricConfigRequest.php | 113 ++++ .../Metrics/Experimental/MetricConfigResponse.php | 201 ++++++ .../Experimental/MetricConfigResponse/Schedule.php | 149 +++++ .../MetricConfigResponse/Schedule/Pattern.php | 113 ++++ .../Experimental/MetricConfigResponse_Schedule.php | 16 + .../MetricConfigResponse_Schedule_Pattern.php | 16 + .../Proto/Metrics/V1/AggregationTemporality.php | 114 ++++ .../Proto/Metrics/V1/DataPointFlags.php | 61 ++ .../Opentelemetry/Proto/Metrics/V1/Exemplar.php | 269 ++++++++ .../Proto/Metrics/V1/ExponentialHistogram.php | 99 +++ .../Metrics/V1/ExponentialHistogramDataPoint.php | 718 +++++++++++++++++++++ .../V1/ExponentialHistogramDataPoint/Buckets.php | 141 ++++ .../V1/ExponentialHistogramDataPoint_Buckets.php | 16 + .../Opentelemetry/Proto/Metrics/V1/Gauge.php | 67 ++ .../Opentelemetry/Proto/Metrics/V1/Histogram.php | 99 +++ .../Proto/Metrics/V1/HistogramDataPoint.php | 565 ++++++++++++++++ .../Metrics/V1/InstrumentationLibraryMetrics.php | 156 +++++ .../Proto/Metrics/V1/IntDataPoint.php | 227 +++++++ .../Opentelemetry/Proto/Metrics/V1/IntExemplar.php | 235 +++++++ .../Opentelemetry/Proto/Metrics/V1/IntGauge.php | 60 ++ .../Proto/Metrics/V1/IntHistogram.php | 99 +++ .../Proto/Metrics/V1/IntHistogramDataPoint.php | 393 +++++++++++ .../Opentelemetry/Proto/Metrics/V1/IntSum.php | 132 ++++ .../Opentelemetry/Proto/Metrics/V1/Metric.php | 358 ++++++++++ .../Opentelemetry/Proto/Metrics/V1/MetricsData.php | 90 +++ .../Proto/Metrics/V1/NumberDataPoint.php | 309 +++++++++ .../Proto/Metrics/V1/ResourceMetrics.php | 153 +++++ .../Proto/Metrics/V1/ScopeMetrics.php | 153 +++++ .../Opentelemetry/Proto/Metrics/V1/Sum.php | 133 ++++ .../Opentelemetry/Proto/Metrics/V1/Summary.php | 65 ++ .../Proto/Metrics/V1/SummaryDataPoint.php | 336 ++++++++++ .../V1/SummaryDataPoint/ValueAtQuantile.php | 117 ++++ .../V1/SummaryDataPoint_ValueAtQuantile.php | 16 + 33 files changed, 5789 insertions(+) create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigRequest.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse/Schedule.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse/Schedule/Pattern.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse_Schedule.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse_Schedule_Pattern.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/AggregationTemporality.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/DataPointFlags.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Exemplar.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogram.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint/Buckets.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint_Buckets.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Gauge.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Histogram.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/HistogramDataPoint.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/InstrumentationLibraryMetrics.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntDataPoint.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntExemplar.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntGauge.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntHistogram.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntHistogramDataPoint.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntSum.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Metric.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/MetricsData.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/NumberDataPoint.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ResourceMetrics.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ScopeMetrics.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Sum.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Summary.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint/ValueAtQuantile.php create mode 100644 vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint_ValueAtQuantile.php (limited to 'vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics') diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigRequest.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigRequest.php new file mode 100644 index 000000000..bdf9ea2fa --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigRequest.php @@ -0,0 +1,113 @@ +opentelemetry.proto.metrics.experimental.MetricConfigRequest + */ +class MetricConfigRequest extends \Google\Protobuf\Internal\Message +{ + /** + * Required. The resource for which configuration should be returned. + * + * Generated from protobuf field .opentelemetry.proto.resource.v1.Resource resource = 1; + */ + protected $resource = null; + /** + * Optional. The value of MetricConfigResponse.fingerprint for the last + * configuration that the caller received and successfully applied. + * + * Generated from protobuf field bytes last_known_fingerprint = 2; + */ + protected $last_known_fingerprint = ''; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Resource\V1\Resource $resource + * Required. The resource for which configuration should be returned. + * @type string $last_known_fingerprint + * Optional. The value of MetricConfigResponse.fingerprint for the last + * configuration that the caller received and successfully applied. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\Experimental\MetricsConfigService::initOnce(); + parent::__construct($data); + } + + /** + * Required. The resource for which configuration should be returned. + * + * Generated from protobuf field .opentelemetry.proto.resource.v1.Resource resource = 1; + * @return \Opentelemetry\Proto\Resource\V1\Resource + */ + public function getResource() + { + return isset($this->resource) ? $this->resource : null; + } + + public function hasResource() + { + return isset($this->resource); + } + + public function clearResource() + { + unset($this->resource); + } + + /** + * Required. The resource for which configuration should be returned. + * + * Generated from protobuf field .opentelemetry.proto.resource.v1.Resource resource = 1; + * @param \Opentelemetry\Proto\Resource\V1\Resource $var + * @return $this + */ + public function setResource($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Resource\V1\Resource::class); + $this->resource = $var; + + return $this; + } + + /** + * Optional. The value of MetricConfigResponse.fingerprint for the last + * configuration that the caller received and successfully applied. + * + * Generated from protobuf field bytes last_known_fingerprint = 2; + * @return string + */ + public function getLastKnownFingerprint() + { + return $this->last_known_fingerprint; + } + + /** + * Optional. The value of MetricConfigResponse.fingerprint for the last + * configuration that the caller received and successfully applied. + * + * Generated from protobuf field bytes last_known_fingerprint = 2; + * @param string $var + * @return $this + */ + public function setLastKnownFingerprint($var) + { + GPBUtil::checkString($var, False); + $this->last_known_fingerprint = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse.php new file mode 100644 index 000000000..0993a59ea --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse.php @@ -0,0 +1,201 @@ +opentelemetry.proto.metrics.experimental.MetricConfigResponse + */ +class MetricConfigResponse extends \Google\Protobuf\Internal\Message +{ + /** + * Optional. The fingerprint associated with this MetricConfigResponse. Each + * change in configs yields a different fingerprint. The resource SHOULD copy + * this value to MetricConfigRequest.last_known_fingerprint for the next + * configuration request. If there are no changes between fingerprint and + * MetricConfigRequest.last_known_fingerprint, then all other fields besides + * fingerprint in the response are optional, or the same as the last update if + * present. + * The exact mechanics of generating the fingerprint is up to the + * implementation. However, a fingerprint must be deterministically determined + * by the configurations -- the same configuration will generate the same + * fingerprint on any instance of an implementation. Hence using a timestamp is + * unacceptable, but a deterministic hash is fine. + * + * Generated from protobuf field bytes fingerprint = 1; + */ + protected $fingerprint = ''; + /** + * A single metric may match multiple schedules. In such cases, the schedule + * that specifies the smallest period is applied. + * Note, for optimization purposes, it is recommended to use as few schedules + * as possible to capture all required metric updates. Where you can be + * conservative, do take full advantage of the inclusion/exclusion patterns to + * capture as much of your targeted metrics. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule schedules = 2; + */ + private $schedules; + /** + * Optional. The client is suggested to wait this long (in seconds) before + * pinging the configuration service again. + * + * Generated from protobuf field int32 suggested_wait_time_sec = 3; + */ + protected $suggested_wait_time_sec = 0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type string $fingerprint + * Optional. The fingerprint associated with this MetricConfigResponse. Each + * change in configs yields a different fingerprint. The resource SHOULD copy + * this value to MetricConfigRequest.last_known_fingerprint for the next + * configuration request. If there are no changes between fingerprint and + * MetricConfigRequest.last_known_fingerprint, then all other fields besides + * fingerprint in the response are optional, or the same as the last update if + * present. + * The exact mechanics of generating the fingerprint is up to the + * implementation. However, a fingerprint must be deterministically determined + * by the configurations -- the same configuration will generate the same + * fingerprint on any instance of an implementation. Hence using a timestamp is + * unacceptable, but a deterministic hash is fine. + * @type \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule[]|\Google\Protobuf\Internal\RepeatedField $schedules + * A single metric may match multiple schedules. In such cases, the schedule + * that specifies the smallest period is applied. + * Note, for optimization purposes, it is recommended to use as few schedules + * as possible to capture all required metric updates. Where you can be + * conservative, do take full advantage of the inclusion/exclusion patterns to + * capture as much of your targeted metrics. + * @type int $suggested_wait_time_sec + * Optional. The client is suggested to wait this long (in seconds) before + * pinging the configuration service again. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\Experimental\MetricsConfigService::initOnce(); + parent::__construct($data); + } + + /** + * Optional. The fingerprint associated with this MetricConfigResponse. Each + * change in configs yields a different fingerprint. The resource SHOULD copy + * this value to MetricConfigRequest.last_known_fingerprint for the next + * configuration request. If there are no changes between fingerprint and + * MetricConfigRequest.last_known_fingerprint, then all other fields besides + * fingerprint in the response are optional, or the same as the last update if + * present. + * The exact mechanics of generating the fingerprint is up to the + * implementation. However, a fingerprint must be deterministically determined + * by the configurations -- the same configuration will generate the same + * fingerprint on any instance of an implementation. Hence using a timestamp is + * unacceptable, but a deterministic hash is fine. + * + * Generated from protobuf field bytes fingerprint = 1; + * @return string + */ + public function getFingerprint() + { + return $this->fingerprint; + } + + /** + * Optional. The fingerprint associated with this MetricConfigResponse. Each + * change in configs yields a different fingerprint. The resource SHOULD copy + * this value to MetricConfigRequest.last_known_fingerprint for the next + * configuration request. If there are no changes between fingerprint and + * MetricConfigRequest.last_known_fingerprint, then all other fields besides + * fingerprint in the response are optional, or the same as the last update if + * present. + * The exact mechanics of generating the fingerprint is up to the + * implementation. However, a fingerprint must be deterministically determined + * by the configurations -- the same configuration will generate the same + * fingerprint on any instance of an implementation. Hence using a timestamp is + * unacceptable, but a deterministic hash is fine. + * + * Generated from protobuf field bytes fingerprint = 1; + * @param string $var + * @return $this + */ + public function setFingerprint($var) + { + GPBUtil::checkString($var, False); + $this->fingerprint = $var; + + return $this; + } + + /** + * A single metric may match multiple schedules. In such cases, the schedule + * that specifies the smallest period is applied. + * Note, for optimization purposes, it is recommended to use as few schedules + * as possible to capture all required metric updates. Where you can be + * conservative, do take full advantage of the inclusion/exclusion patterns to + * capture as much of your targeted metrics. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule schedules = 2; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getSchedules() + { + return $this->schedules; + } + + /** + * A single metric may match multiple schedules. In such cases, the schedule + * that specifies the smallest period is applied. + * Note, for optimization purposes, it is recommended to use as few schedules + * as possible to capture all required metric updates. Where you can be + * conservative, do take full advantage of the inclusion/exclusion patterns to + * capture as much of your targeted metrics. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule schedules = 2; + * @param \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setSchedules($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule::class); + $this->schedules = $arr; + + return $this; + } + + /** + * Optional. The client is suggested to wait this long (in seconds) before + * pinging the configuration service again. + * + * Generated from protobuf field int32 suggested_wait_time_sec = 3; + * @return int + */ + public function getSuggestedWaitTimeSec() + { + return $this->suggested_wait_time_sec; + } + + /** + * Optional. The client is suggested to wait this long (in seconds) before + * pinging the configuration service again. + * + * Generated from protobuf field int32 suggested_wait_time_sec = 3; + * @param int $var + * @return $this + */ + public function setSuggestedWaitTimeSec($var) + { + GPBUtil::checkInt32($var); + $this->suggested_wait_time_sec = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse/Schedule.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse/Schedule.php new file mode 100644 index 000000000..07091928d --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse/Schedule.php @@ -0,0 +1,149 @@ +opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule + */ +class Schedule extends \Google\Protobuf\Internal\Message +{ + /** + * Metrics with names that match a rule in the inclusion_patterns are + * targeted by this schedule. Metrics that match the exclusion_patterns + * are not targeted for this schedule, even if they match an inclusion + * pattern. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule.Pattern exclusion_patterns = 1; + */ + private $exclusion_patterns; + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule.Pattern inclusion_patterns = 2; + */ + private $inclusion_patterns; + /** + * Describes the collection period for each metric in seconds. + * A period of 0 means to not export. + * + * Generated from protobuf field int32 period_sec = 3; + */ + protected $period_sec = 0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule\Pattern[]|\Google\Protobuf\Internal\RepeatedField $exclusion_patterns + * Metrics with names that match a rule in the inclusion_patterns are + * targeted by this schedule. Metrics that match the exclusion_patterns + * are not targeted for this schedule, even if they match an inclusion + * pattern. + * @type \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule\Pattern[]|\Google\Protobuf\Internal\RepeatedField $inclusion_patterns + * @type int $period_sec + * Describes the collection period for each metric in seconds. + * A period of 0 means to not export. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\Experimental\MetricsConfigService::initOnce(); + parent::__construct($data); + } + + /** + * Metrics with names that match a rule in the inclusion_patterns are + * targeted by this schedule. Metrics that match the exclusion_patterns + * are not targeted for this schedule, even if they match an inclusion + * pattern. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule.Pattern exclusion_patterns = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getExclusionPatterns() + { + return $this->exclusion_patterns; + } + + /** + * Metrics with names that match a rule in the inclusion_patterns are + * targeted by this schedule. Metrics that match the exclusion_patterns + * are not targeted for this schedule, even if they match an inclusion + * pattern. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule.Pattern exclusion_patterns = 1; + * @param \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule\Pattern[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setExclusionPatterns($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule\Pattern::class); + $this->exclusion_patterns = $arr; + + return $this; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule.Pattern inclusion_patterns = 2; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getInclusionPatterns() + { + return $this->inclusion_patterns; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule.Pattern inclusion_patterns = 2; + * @param \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule\Pattern[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setInclusionPatterns($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule\Pattern::class); + $this->inclusion_patterns = $arr; + + return $this; + } + + /** + * Describes the collection period for each metric in seconds. + * A period of 0 means to not export. + * + * Generated from protobuf field int32 period_sec = 3; + * @return int + */ + public function getPeriodSec() + { + return $this->period_sec; + } + + /** + * Describes the collection period for each metric in seconds. + * A period of 0 means to not export. + * + * Generated from protobuf field int32 period_sec = 3; + * @param int $var + * @return $this + */ + public function setPeriodSec($var) + { + GPBUtil::checkInt32($var); + $this->period_sec = $var; + + return $this; + } + +} + +// Adding a class alias for backwards compatibility with the previous class name. +class_alias(Schedule::class, \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse_Schedule::class); + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse/Schedule/Pattern.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse/Schedule/Pattern.php new file mode 100644 index 000000000..839c097fb --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse/Schedule/Pattern.php @@ -0,0 +1,113 @@ +opentelemetry.proto.metrics.experimental.MetricConfigResponse.Schedule.Pattern + */ +class Pattern extends \Google\Protobuf\Internal\Message +{ + protected $match; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type string $equals + * matches the metric name exactly + * @type string $starts_with + * prefix-matches the metric name + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\Experimental\MetricsConfigService::initOnce(); + parent::__construct($data); + } + + /** + * matches the metric name exactly + * + * Generated from protobuf field string equals = 1; + * @return string + */ + public function getEquals() + { + return $this->readOneof(1); + } + + public function hasEquals() + { + return $this->hasOneof(1); + } + + /** + * matches the metric name exactly + * + * Generated from protobuf field string equals = 1; + * @param string $var + * @return $this + */ + public function setEquals($var) + { + GPBUtil::checkString($var, True); + $this->writeOneof(1, $var); + + return $this; + } + + /** + * prefix-matches the metric name + * + * Generated from protobuf field string starts_with = 2; + * @return string + */ + public function getStartsWith() + { + return $this->readOneof(2); + } + + public function hasStartsWith() + { + return $this->hasOneof(2); + } + + /** + * prefix-matches the metric name + * + * Generated from protobuf field string starts_with = 2; + * @param string $var + * @return $this + */ + public function setStartsWith($var) + { + GPBUtil::checkString($var, True); + $this->writeOneof(2, $var); + + return $this; + } + + /** + * @return string + */ + public function getMatch() + { + return $this->whichOneof("match"); + } + +} + +// Adding a class alias for backwards compatibility with the previous class name. +class_alias(Pattern::class, \Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse_Schedule_Pattern::class); + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse_Schedule.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse_Schedule.php new file mode 100644 index 000000000..5486976fc --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/Experimental/MetricConfigResponse_Schedule.php @@ -0,0 +1,16 @@ +opentelemetry.proto.metrics.v1.AggregationTemporality + */ +class AggregationTemporality +{ + /** + * UNSPECIFIED is the default AggregationTemporality, it MUST not be used. + * + * Generated from protobuf enum AGGREGATION_TEMPORALITY_UNSPECIFIED = 0; + */ + const AGGREGATION_TEMPORALITY_UNSPECIFIED = 0; + /** + * DELTA is an AggregationTemporality for a metric aggregator which reports + * changes since last report time. Successive metrics contain aggregation of + * values from continuous and non-overlapping intervals. + * The values for a DELTA metric are based only on the time interval + * associated with one measurement cycle. There is no dependency on + * previous measurements like is the case for CUMULATIVE metrics. + * For example, consider a system measuring the number of requests that + * it receives and reports the sum of these requests every second as a + * DELTA metric: + * 1. The system starts receiving at time=t_0. + * 2. A request is received, the system measures 1 request. + * 3. A request is received, the system measures 1 request. + * 4. A request is received, the system measures 1 request. + * 5. The 1 second collection cycle ends. A metric is exported for the + * number of requests received over the interval of time t_0 to + * t_0+1 with a value of 3. + * 6. A request is received, the system measures 1 request. + * 7. A request is received, the system measures 1 request. + * 8. The 1 second collection cycle ends. A metric is exported for the + * number of requests received over the interval of time t_0+1 to + * t_0+2 with a value of 2. + * + * Generated from protobuf enum AGGREGATION_TEMPORALITY_DELTA = 1; + */ + const AGGREGATION_TEMPORALITY_DELTA = 1; + /** + * CUMULATIVE is an AggregationTemporality for a metric aggregator which + * reports changes since a fixed start time. This means that current values + * of a CUMULATIVE metric depend on all previous measurements since the + * start time. Because of this, the sender is required to retain this state + * in some form. If this state is lost or invalidated, the CUMULATIVE metric + * values MUST be reset and a new fixed start time following the last + * reported measurement time sent MUST be used. + * For example, consider a system measuring the number of requests that + * it receives and reports the sum of these requests every second as a + * CUMULATIVE metric: + * 1. The system starts receiving at time=t_0. + * 2. A request is received, the system measures 1 request. + * 3. A request is received, the system measures 1 request. + * 4. A request is received, the system measures 1 request. + * 5. The 1 second collection cycle ends. A metric is exported for the + * number of requests received over the interval of time t_0 to + * t_0+1 with a value of 3. + * 6. A request is received, the system measures 1 request. + * 7. A request is received, the system measures 1 request. + * 8. The 1 second collection cycle ends. A metric is exported for the + * number of requests received over the interval of time t_0 to + * t_0+2 with a value of 5. + * 9. The system experiences a fault and loses state. + * 10. The system recovers and resumes receiving at time=t_1. + * 11. A request is received, the system measures 1 request. + * 12. The 1 second collection cycle ends. A metric is exported for the + * number of requests received over the interval of time t_1 to + * t_0+1 with a value of 1. + * Note: Even though, when reporting changes since last report time, using + * CUMULATIVE is valid, it is not recommended. This may cause problems for + * systems that do not use start_time to determine when the aggregation + * value was reset (e.g. Prometheus). + * + * Generated from protobuf enum AGGREGATION_TEMPORALITY_CUMULATIVE = 2; + */ + const AGGREGATION_TEMPORALITY_CUMULATIVE = 2; + + private static $valueToName = [ + self::AGGREGATION_TEMPORALITY_UNSPECIFIED => 'AGGREGATION_TEMPORALITY_UNSPECIFIED', + self::AGGREGATION_TEMPORALITY_DELTA => 'AGGREGATION_TEMPORALITY_DELTA', + self::AGGREGATION_TEMPORALITY_CUMULATIVE => 'AGGREGATION_TEMPORALITY_CUMULATIVE', + ]; + + public static function name($value) + { + if (!isset(self::$valueToName[$value])) { + throw new UnexpectedValueException(sprintf( + 'Enum %s has no name defined for value %s', __CLASS__, $value)); + } + return self::$valueToName[$value]; + } + + + public static function value($name) + { + $const = __CLASS__ . '::' . strtoupper($name); + if (!defined($const)) { + throw new UnexpectedValueException(sprintf( + 'Enum %s has no value defined for name %s', __CLASS__, $name)); + } + return constant($const); + } +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/DataPointFlags.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/DataPointFlags.php new file mode 100644 index 000000000..f11029d02 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/DataPointFlags.php @@ -0,0 +1,61 @@ +opentelemetry.proto.metrics.v1.DataPointFlags + */ +class DataPointFlags +{ + /** + * The zero value for the enum. Should not be used for comparisons. + * Instead use bitwise "and" with the appropriate mask as shown above. + * + * Generated from protobuf enum DATA_POINT_FLAGS_DO_NOT_USE = 0; + */ + const DATA_POINT_FLAGS_DO_NOT_USE = 0; + /** + * This DataPoint is valid but has no recorded value. This value + * SHOULD be used to reflect explicitly missing data in a series, as + * for an equivalent to the Prometheus "staleness marker". + * + * Generated from protobuf enum DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK = 1; + */ + const DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK = 1; + + private static $valueToName = [ + self::DATA_POINT_FLAGS_DO_NOT_USE => 'DATA_POINT_FLAGS_DO_NOT_USE', + self::DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK => 'DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK', + ]; + + public static function name($value) + { + if (!isset(self::$valueToName[$value])) { + throw new UnexpectedValueException(sprintf( + 'Enum %s has no name defined for value %s', __CLASS__, $value)); + } + return self::$valueToName[$value]; + } + + + public static function value($name) + { + $const = __CLASS__ . '::' . strtoupper($name); + if (!defined($const)) { + throw new UnexpectedValueException(sprintf( + 'Enum %s has no value defined for name %s', __CLASS__, $name)); + } + return constant($const); + } +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Exemplar.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Exemplar.php new file mode 100644 index 000000000..a0387ede1 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Exemplar.php @@ -0,0 +1,269 @@ +opentelemetry.proto.metrics.v1.Exemplar + */ +class Exemplar extends \Google\Protobuf\Internal\Message +{ + /** + * 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 + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue filtered_attributes = 7; + */ + private $filtered_attributes; + /** + * time_unix_nano is the exact time when this exemplar was recorded + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 2; + */ + protected $time_unix_nano = 0; + /** + * (Optional) Span ID of the exemplar trace. + * span_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes span_id = 4; + */ + protected $span_id = ''; + /** + * (Optional) Trace ID of the exemplar trace. + * trace_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes trace_id = 5; + */ + protected $trace_id = ''; + protected $value; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $filtered_attributes + * 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 + * @type int|string $time_unix_nano + * time_unix_nano is the exact time when this exemplar was recorded + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type float $as_double + * @type int|string $as_int + * @type string $span_id + * (Optional) Span ID of the exemplar trace. + * span_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * @type string $trace_id + * (Optional) Trace ID of the exemplar trace. + * trace_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * 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 + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue filtered_attributes = 7; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getFilteredAttributes() + { + return $this->filtered_attributes; + } + + /** + * 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 + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue filtered_attributes = 7; + * @param \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setFilteredAttributes($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Common\V1\KeyValue::class); + $this->filtered_attributes = $arr; + + return $this; + } + + /** + * time_unix_nano is the exact time when this exemplar was recorded + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 2; + * @return int|string + */ + public function getTimeUnixNano() + { + return $this->time_unix_nano; + } + + /** + * time_unix_nano is the exact time when this exemplar was recorded + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 2; + * @param int|string $var + * @return $this + */ + public function setTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->time_unix_nano = $var; + + return $this; + } + + /** + * Generated from protobuf field double as_double = 3; + * @return float + */ + public function getAsDouble() + { + return $this->readOneof(3); + } + + public function hasAsDouble() + { + return $this->hasOneof(3); + } + + /** + * Generated from protobuf field double as_double = 3; + * @param float $var + * @return $this + */ + public function setAsDouble($var) + { + GPBUtil::checkDouble($var); + $this->writeOneof(3, $var); + + return $this; + } + + /** + * Generated from protobuf field sfixed64 as_int = 6; + * @return int|string + */ + public function getAsInt() + { + return $this->readOneof(6); + } + + public function hasAsInt() + { + return $this->hasOneof(6); + } + + /** + * Generated from protobuf field sfixed64 as_int = 6; + * @param int|string $var + * @return $this + */ + public function setAsInt($var) + { + GPBUtil::checkInt64($var); + $this->writeOneof(6, $var); + + return $this; + } + + /** + * (Optional) Span ID of the exemplar trace. + * span_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes span_id = 4; + * @return string + */ + public function getSpanId() + { + return $this->span_id; + } + + /** + * (Optional) Span ID of the exemplar trace. + * span_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes span_id = 4; + * @param string $var + * @return $this + */ + public function setSpanId($var) + { + GPBUtil::checkString($var, False); + $this->span_id = $var; + + return $this; + } + + /** + * (Optional) Trace ID of the exemplar trace. + * trace_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes trace_id = 5; + * @return string + */ + public function getTraceId() + { + return $this->trace_id; + } + + /** + * (Optional) Trace ID of the exemplar trace. + * trace_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes trace_id = 5; + * @param string $var + * @return $this + */ + public function setTraceId($var) + { + GPBUtil::checkString($var, False); + $this->trace_id = $var; + + return $this; + } + + /** + * @return string + */ + public function getValue() + { + return $this->whichOneof("value"); + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogram.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogram.php new file mode 100644 index 000000000..2a5c4cc90 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogram.php @@ -0,0 +1,99 @@ +opentelemetry.proto.metrics.v1.ExponentialHistogram + */ +class ExponentialHistogram extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint data_points = 1; + */ + private $data_points; + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + */ + protected $aggregation_temporality = 0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint[]|\Google\Protobuf\Internal\RepeatedField $data_points + * @type int $aggregation_temporality + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint data_points = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getDataPoints() + { + return $this->data_points; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint data_points = 1; + * @param \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setDataPoints($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint::class); + $this->data_points = $arr; + + return $this; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @return int + */ + public function getAggregationTemporality() + { + return $this->aggregation_temporality; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @param int $var + * @return $this + */ + public function setAggregationTemporality($var) + { + GPBUtil::checkEnum($var, \Opentelemetry\Proto\Metrics\V1\AggregationTemporality::class); + $this->aggregation_temporality = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint.php new file mode 100644 index 000000000..62cb6f5d6 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint.php @@ -0,0 +1,718 @@ +opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint + */ +class ExponentialHistogramDataPoint extends \Google\Protobuf\Internal\Message +{ + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 1; + */ + private $attributes; + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + */ + protected $start_time_unix_nano = 0; + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + */ + protected $time_unix_nano = 0; + /** + * count is the number of values in the population. Must be + * non-negative. This value must be equal to the sum of the "bucket_counts" + * values in the positive and negative Buckets plus the "zero_count" field. + * + * Generated from protobuf field fixed64 count = 4; + */ + protected $count = 0; + /** + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram + * + * Generated from protobuf field optional double sum = 5; + */ + protected $sum = null; + /** + * scale describes the resolution of the histogram. Boundaries are + * located at powers of the base, where: + * base = (2^(2^-scale)) + * The histogram bucket identified by `index`, a signed integer, + * contains values that are greater than (base^index) and + * less than or equal to (base^(index+1)). + * The positive and negative ranges of the histogram are expressed + * separately. Negative values are mapped by their absolute value + * into the negative range using the same scale as the positive range. + * scale is not restricted by the protocol, as the permissible + * values depend on the range of the data. + * + * Generated from protobuf field sint32 scale = 6; + */ + protected $scale = 0; + /** + * zero_count is the count of values that are either exactly zero or + * within the region considered zero by the instrumentation at the + * tolerated degree of precision. This bucket stores values that + * cannot be expressed using the standard exponential formula as + * well as values that have been rounded to zero. + * Implementations MAY consider the zero bucket to have probability + * mass equal to (zero_count / count). + * + * Generated from protobuf field fixed64 zero_count = 7; + */ + protected $zero_count = 0; + /** + * positive carries the positive range of exponential bucket counts. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets positive = 8; + */ + protected $positive = null; + /** + * negative carries the negative range of exponential bucket counts. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets negative = 9; + */ + protected $negative = null; + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 10; + */ + protected $flags = 0; + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 11; + */ + private $exemplars; + /** + * min is the minimum value over (start_time, end_time]. + * + * Generated from protobuf field optional double min = 12; + */ + protected $min = null; + /** + * max is the maximum value over (start_time, end_time]. + * + * Generated from protobuf field optional double max = 13; + */ + protected $max = null; + /** + * ZeroThreshold may be optionally set to convey the width of the zero + * region. Where the zero region is defined as the closed interval + * [-ZeroThreshold, ZeroThreshold]. + * When ZeroThreshold is 0, zero count bucket stores values that cannot be + * expressed using the standard exponential formula as well as values that + * have been rounded to zero. + * + * Generated from protobuf field double zero_threshold = 14; + */ + protected $zero_threshold = 0.0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $attributes + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * @type int|string $start_time_unix_nano + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $time_unix_nano + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $count + * count is the number of values in the population. Must be + * non-negative. This value must be equal to the sum of the "bucket_counts" + * values in the positive and negative Buckets plus the "zero_count" field. + * @type float $sum + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram + * @type int $scale + * scale describes the resolution of the histogram. Boundaries are + * located at powers of the base, where: + * base = (2^(2^-scale)) + * The histogram bucket identified by `index`, a signed integer, + * contains values that are greater than (base^index) and + * less than or equal to (base^(index+1)). + * The positive and negative ranges of the histogram are expressed + * separately. Negative values are mapped by their absolute value + * into the negative range using the same scale as the positive range. + * scale is not restricted by the protocol, as the permissible + * values depend on the range of the data. + * @type int|string $zero_count + * zero_count is the count of values that are either exactly zero or + * within the region considered zero by the instrumentation at the + * tolerated degree of precision. This bucket stores values that + * cannot be expressed using the standard exponential formula as + * well as values that have been rounded to zero. + * Implementations MAY consider the zero bucket to have probability + * mass equal to (zero_count / count). + * @type \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint\Buckets $positive + * positive carries the positive range of exponential bucket counts. + * @type \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint\Buckets $negative + * negative carries the negative range of exponential bucket counts. + * @type int $flags + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * @type \Opentelemetry\Proto\Metrics\V1\Exemplar[]|\Google\Protobuf\Internal\RepeatedField $exemplars + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * @type float $min + * min is the minimum value over (start_time, end_time]. + * @type float $max + * max is the maximum value over (start_time, end_time]. + * @type float $zero_threshold + * ZeroThreshold may be optionally set to convey the width of the zero + * region. Where the zero region is defined as the closed interval + * [-ZeroThreshold, ZeroThreshold]. + * When ZeroThreshold is 0, zero count bucket stores values that cannot be + * expressed using the standard exponential formula as well as values that + * have been rounded to zero. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getAttributes() + { + return $this->attributes; + } + + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 1; + * @param \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setAttributes($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Common\V1\KeyValue::class); + $this->attributes = $arr; + + return $this; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @return int|string + */ + public function getStartTimeUnixNano() + { + return $this->start_time_unix_nano; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @param int|string $var + * @return $this + */ + public function setStartTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->start_time_unix_nano = $var; + + return $this; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @return int|string + */ + public function getTimeUnixNano() + { + return $this->time_unix_nano; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @param int|string $var + * @return $this + */ + public function setTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->time_unix_nano = $var; + + return $this; + } + + /** + * count is the number of values in the population. Must be + * non-negative. This value must be equal to the sum of the "bucket_counts" + * values in the positive and negative Buckets plus the "zero_count" field. + * + * Generated from protobuf field fixed64 count = 4; + * @return int|string + */ + public function getCount() + { + return $this->count; + } + + /** + * count is the number of values in the population. Must be + * non-negative. This value must be equal to the sum of the "bucket_counts" + * values in the positive and negative Buckets plus the "zero_count" field. + * + * Generated from protobuf field fixed64 count = 4; + * @param int|string $var + * @return $this + */ + public function setCount($var) + { + GPBUtil::checkUint64($var); + $this->count = $var; + + return $this; + } + + /** + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram + * + * Generated from protobuf field optional double sum = 5; + * @return float + */ + public function getSum() + { + return isset($this->sum) ? $this->sum : 0.0; + } + + public function hasSum() + { + return isset($this->sum); + } + + public function clearSum() + { + unset($this->sum); + } + + /** + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram + * + * Generated from protobuf field optional double sum = 5; + * @param float $var + * @return $this + */ + public function setSum($var) + { + GPBUtil::checkDouble($var); + $this->sum = $var; + + return $this; + } + + /** + * scale describes the resolution of the histogram. Boundaries are + * located at powers of the base, where: + * base = (2^(2^-scale)) + * The histogram bucket identified by `index`, a signed integer, + * contains values that are greater than (base^index) and + * less than or equal to (base^(index+1)). + * The positive and negative ranges of the histogram are expressed + * separately. Negative values are mapped by their absolute value + * into the negative range using the same scale as the positive range. + * scale is not restricted by the protocol, as the permissible + * values depend on the range of the data. + * + * Generated from protobuf field sint32 scale = 6; + * @return int + */ + public function getScale() + { + return $this->scale; + } + + /** + * scale describes the resolution of the histogram. Boundaries are + * located at powers of the base, where: + * base = (2^(2^-scale)) + * The histogram bucket identified by `index`, a signed integer, + * contains values that are greater than (base^index) and + * less than or equal to (base^(index+1)). + * The positive and negative ranges of the histogram are expressed + * separately. Negative values are mapped by their absolute value + * into the negative range using the same scale as the positive range. + * scale is not restricted by the protocol, as the permissible + * values depend on the range of the data. + * + * Generated from protobuf field sint32 scale = 6; + * @param int $var + * @return $this + */ + public function setScale($var) + { + GPBUtil::checkInt32($var); + $this->scale = $var; + + return $this; + } + + /** + * zero_count is the count of values that are either exactly zero or + * within the region considered zero by the instrumentation at the + * tolerated degree of precision. This bucket stores values that + * cannot be expressed using the standard exponential formula as + * well as values that have been rounded to zero. + * Implementations MAY consider the zero bucket to have probability + * mass equal to (zero_count / count). + * + * Generated from protobuf field fixed64 zero_count = 7; + * @return int|string + */ + public function getZeroCount() + { + return $this->zero_count; + } + + /** + * zero_count is the count of values that are either exactly zero or + * within the region considered zero by the instrumentation at the + * tolerated degree of precision. This bucket stores values that + * cannot be expressed using the standard exponential formula as + * well as values that have been rounded to zero. + * Implementations MAY consider the zero bucket to have probability + * mass equal to (zero_count / count). + * + * Generated from protobuf field fixed64 zero_count = 7; + * @param int|string $var + * @return $this + */ + public function setZeroCount($var) + { + GPBUtil::checkUint64($var); + $this->zero_count = $var; + + return $this; + } + + /** + * positive carries the positive range of exponential bucket counts. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets positive = 8; + * @return \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint\Buckets|null + */ + public function getPositive() + { + return $this->positive; + } + + public function hasPositive() + { + return isset($this->positive); + } + + public function clearPositive() + { + unset($this->positive); + } + + /** + * positive carries the positive range of exponential bucket counts. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets positive = 8; + * @param \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint\Buckets $var + * @return $this + */ + public function setPositive($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint\Buckets::class); + $this->positive = $var; + + return $this; + } + + /** + * negative carries the negative range of exponential bucket counts. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets negative = 9; + * @return \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint\Buckets|null + */ + public function getNegative() + { + return $this->negative; + } + + public function hasNegative() + { + return isset($this->negative); + } + + public function clearNegative() + { + unset($this->negative); + } + + /** + * negative carries the negative range of exponential bucket counts. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets negative = 9; + * @param \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint\Buckets $var + * @return $this + */ + public function setNegative($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint\Buckets::class); + $this->negative = $var; + + return $this; + } + + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 10; + * @return int + */ + public function getFlags() + { + return $this->flags; + } + + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 10; + * @param int $var + * @return $this + */ + public function setFlags($var) + { + GPBUtil::checkUint32($var); + $this->flags = $var; + + return $this; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 11; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getExemplars() + { + return $this->exemplars; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 11; + * @param \Opentelemetry\Proto\Metrics\V1\Exemplar[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setExemplars($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\Exemplar::class); + $this->exemplars = $arr; + + return $this; + } + + /** + * min is the minimum value over (start_time, end_time]. + * + * Generated from protobuf field optional double min = 12; + * @return float + */ + public function getMin() + { + return isset($this->min) ? $this->min : 0.0; + } + + public function hasMin() + { + return isset($this->min); + } + + public function clearMin() + { + unset($this->min); + } + + /** + * min is the minimum value over (start_time, end_time]. + * + * Generated from protobuf field optional double min = 12; + * @param float $var + * @return $this + */ + public function setMin($var) + { + GPBUtil::checkDouble($var); + $this->min = $var; + + return $this; + } + + /** + * max is the maximum value over (start_time, end_time]. + * + * Generated from protobuf field optional double max = 13; + * @return float + */ + public function getMax() + { + return isset($this->max) ? $this->max : 0.0; + } + + public function hasMax() + { + return isset($this->max); + } + + public function clearMax() + { + unset($this->max); + } + + /** + * max is the maximum value over (start_time, end_time]. + * + * Generated from protobuf field optional double max = 13; + * @param float $var + * @return $this + */ + public function setMax($var) + { + GPBUtil::checkDouble($var); + $this->max = $var; + + return $this; + } + + /** + * ZeroThreshold may be optionally set to convey the width of the zero + * region. Where the zero region is defined as the closed interval + * [-ZeroThreshold, ZeroThreshold]. + * When ZeroThreshold is 0, zero count bucket stores values that cannot be + * expressed using the standard exponential formula as well as values that + * have been rounded to zero. + * + * Generated from protobuf field double zero_threshold = 14; + * @return float + */ + public function getZeroThreshold() + { + return $this->zero_threshold; + } + + /** + * ZeroThreshold may be optionally set to convey the width of the zero + * region. Where the zero region is defined as the closed interval + * [-ZeroThreshold, ZeroThreshold]. + * When ZeroThreshold is 0, zero count bucket stores values that cannot be + * expressed using the standard exponential formula as well as values that + * have been rounded to zero. + * + * Generated from protobuf field double zero_threshold = 14; + * @param float $var + * @return $this + */ + public function setZeroThreshold($var) + { + GPBUtil::checkDouble($var); + $this->zero_threshold = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint/Buckets.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint/Buckets.php new file mode 100644 index 000000000..e1a90a34a --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint/Buckets.php @@ -0,0 +1,141 @@ +opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets + */ +class Buckets extends \Google\Protobuf\Internal\Message +{ + /** + * Offset is the bucket index of the first entry in the bucket_counts array. + * + * Note: This uses a varint encoding as a simple form of compression. + * + * Generated from protobuf field sint32 offset = 1; + */ + protected $offset = 0; + /** + * bucket_counts is an array of count values, where bucket_counts[i] carries + * the count of the bucket at index (offset+i). bucket_counts[i] is the count + * of values greater than base^(offset+i) and less than or equal to + * base^(offset+i+1). + * Note: By contrast, the explicit HistogramDataPoint uses + * fixed64. This field is expected to have many buckets, + * especially zeros, so uint64 has been selected to ensure + * varint encoding. + * + * Generated from protobuf field repeated uint64 bucket_counts = 2; + */ + private $bucket_counts; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type int $offset + * Offset is the bucket index of the first entry in the bucket_counts array. + * + * Note: This uses a varint encoding as a simple form of compression. + * @type int[]|string[]|\Google\Protobuf\Internal\RepeatedField $bucket_counts + * bucket_counts is an array of count values, where bucket_counts[i] carries + * the count of the bucket at index (offset+i). bucket_counts[i] is the count + * of values greater than base^(offset+i) and less than or equal to + * base^(offset+i+1). + * Note: By contrast, the explicit HistogramDataPoint uses + * fixed64. This field is expected to have many buckets, + * especially zeros, so uint64 has been selected to ensure + * varint encoding. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * Offset is the bucket index of the first entry in the bucket_counts array. + * + * Note: This uses a varint encoding as a simple form of compression. + * + * Generated from protobuf field sint32 offset = 1; + * @return int + */ + public function getOffset() + { + return $this->offset; + } + + /** + * Offset is the bucket index of the first entry in the bucket_counts array. + * + * Note: This uses a varint encoding as a simple form of compression. + * + * Generated from protobuf field sint32 offset = 1; + * @param int $var + * @return $this + */ + public function setOffset($var) + { + GPBUtil::checkInt32($var); + $this->offset = $var; + + return $this; + } + + /** + * bucket_counts is an array of count values, where bucket_counts[i] carries + * the count of the bucket at index (offset+i). bucket_counts[i] is the count + * of values greater than base^(offset+i) and less than or equal to + * base^(offset+i+1). + * Note: By contrast, the explicit HistogramDataPoint uses + * fixed64. This field is expected to have many buckets, + * especially zeros, so uint64 has been selected to ensure + * varint encoding. + * + * Generated from protobuf field repeated uint64 bucket_counts = 2; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getBucketCounts() + { + return $this->bucket_counts; + } + + /** + * bucket_counts is an array of count values, where bucket_counts[i] carries + * the count of the bucket at index (offset+i). bucket_counts[i] is the count + * of values greater than base^(offset+i) and less than or equal to + * base^(offset+i+1). + * Note: By contrast, the explicit HistogramDataPoint uses + * fixed64. This field is expected to have many buckets, + * especially zeros, so uint64 has been selected to ensure + * varint encoding. + * + * Generated from protobuf field repeated uint64 bucket_counts = 2; + * @param int[]|string[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setBucketCounts($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::UINT64); + $this->bucket_counts = $arr; + + return $this; + } + +} + +// Adding a class alias for backwards compatibility with the previous class name. +class_alias(Buckets::class, \Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint_Buckets::class); + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint_Buckets.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint_Buckets.php new file mode 100644 index 000000000..a002399a8 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ExponentialHistogramDataPoint_Buckets.php @@ -0,0 +1,16 @@ +opentelemetry.proto.metrics.v1.Gauge + */ +class Gauge extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.NumberDataPoint data_points = 1; + */ + private $data_points; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\V1\NumberDataPoint[]|\Google\Protobuf\Internal\RepeatedField $data_points + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.NumberDataPoint data_points = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getDataPoints() + { + return $this->data_points; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.NumberDataPoint data_points = 1; + * @param \Opentelemetry\Proto\Metrics\V1\NumberDataPoint[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setDataPoints($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\NumberDataPoint::class); + $this->data_points = $arr; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Histogram.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Histogram.php new file mode 100644 index 000000000..e6643b89e --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Histogram.php @@ -0,0 +1,99 @@ +opentelemetry.proto.metrics.v1.Histogram + */ +class Histogram extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.HistogramDataPoint data_points = 1; + */ + private $data_points; + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + */ + protected $aggregation_temporality = 0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\V1\HistogramDataPoint[]|\Google\Protobuf\Internal\RepeatedField $data_points + * @type int $aggregation_temporality + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.HistogramDataPoint data_points = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getDataPoints() + { + return $this->data_points; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.HistogramDataPoint data_points = 1; + * @param \Opentelemetry\Proto\Metrics\V1\HistogramDataPoint[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setDataPoints($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\HistogramDataPoint::class); + $this->data_points = $arr; + + return $this; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @return int + */ + public function getAggregationTemporality() + { + return $this->aggregation_temporality; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @param int $var + * @return $this + */ + public function setAggregationTemporality($var) + { + GPBUtil::checkEnum($var, \Opentelemetry\Proto\Metrics\V1\AggregationTemporality::class); + $this->aggregation_temporality = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/HistogramDataPoint.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/HistogramDataPoint.php new file mode 100644 index 000000000..2b19dd856 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/HistogramDataPoint.php @@ -0,0 +1,565 @@ +opentelemetry.proto.metrics.v1.HistogramDataPoint + */ +class HistogramDataPoint extends \Google\Protobuf\Internal\Message +{ + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 9; + */ + private $attributes; + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + */ + protected $start_time_unix_nano = 0; + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + */ + protected $time_unix_nano = 0; + /** + * count is the number of values in the population. Must be non-negative. This + * value must be equal to the sum of the "count" fields in buckets if a + * histogram is provided. + * + * Generated from protobuf field fixed64 count = 4; + */ + protected $count = 0; + /** + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram + * + * Generated from protobuf field optional double sum = 5; + */ + protected $sum = null; + /** + * bucket_counts is an optional field contains the count values of histogram + * for each bucket. + * The sum of the bucket_counts must equal the value in the count field. + * The number of elements in bucket_counts array must be by one greater than + * the number of elements in explicit_bounds array. + * + * Generated from protobuf field repeated fixed64 bucket_counts = 6; + */ + private $bucket_counts; + /** + * explicit_bounds specifies buckets with explicitly defined bounds for values. + * The boundaries for bucket at index i are: + * (-infinity, explicit_bounds[i]] for i == 0 + * (explicit_bounds[i-1], explicit_bounds[i]] for 0 < i < size(explicit_bounds) + * (explicit_bounds[i-1], +infinity) for i == size(explicit_bounds) + * The values in the explicit_bounds array must be strictly increasing. + * Histogram buckets are inclusive of their upper boundary, except the last + * bucket where the boundary is at infinity. This format is intentionally + * compatible with the OpenMetrics histogram definition. + * + * Generated from protobuf field repeated double explicit_bounds = 7; + */ + private $explicit_bounds; + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 8; + */ + private $exemplars; + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 10; + */ + protected $flags = 0; + /** + * min is the minimum value over (start_time, end_time]. + * + * Generated from protobuf field optional double min = 11; + */ + protected $min = null; + /** + * max is the maximum value over (start_time, end_time]. + * + * Generated from protobuf field optional double max = 12; + */ + protected $max = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $attributes + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * @type int|string $start_time_unix_nano + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $time_unix_nano + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $count + * count is the number of values in the population. Must be non-negative. This + * value must be equal to the sum of the "count" fields in buckets if a + * histogram is provided. + * @type float $sum + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram + * @type int[]|string[]|\Google\Protobuf\Internal\RepeatedField $bucket_counts + * bucket_counts is an optional field contains the count values of histogram + * for each bucket. + * The sum of the bucket_counts must equal the value in the count field. + * The number of elements in bucket_counts array must be by one greater than + * the number of elements in explicit_bounds array. + * @type float[]|\Google\Protobuf\Internal\RepeatedField $explicit_bounds + * explicit_bounds specifies buckets with explicitly defined bounds for values. + * The boundaries for bucket at index i are: + * (-infinity, explicit_bounds[i]] for i == 0 + * (explicit_bounds[i-1], explicit_bounds[i]] for 0 < i < size(explicit_bounds) + * (explicit_bounds[i-1], +infinity) for i == size(explicit_bounds) + * The values in the explicit_bounds array must be strictly increasing. + * Histogram buckets are inclusive of their upper boundary, except the last + * bucket where the boundary is at infinity. This format is intentionally + * compatible with the OpenMetrics histogram definition. + * @type \Opentelemetry\Proto\Metrics\V1\Exemplar[]|\Google\Protobuf\Internal\RepeatedField $exemplars + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * @type int $flags + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * @type float $min + * min is the minimum value over (start_time, end_time]. + * @type float $max + * max is the maximum value over (start_time, end_time]. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 9; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getAttributes() + { + return $this->attributes; + } + + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 9; + * @param \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setAttributes($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Common\V1\KeyValue::class); + $this->attributes = $arr; + + return $this; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @return int|string + */ + public function getStartTimeUnixNano() + { + return $this->start_time_unix_nano; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @param int|string $var + * @return $this + */ + public function setStartTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->start_time_unix_nano = $var; + + return $this; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @return int|string + */ + public function getTimeUnixNano() + { + return $this->time_unix_nano; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @param int|string $var + * @return $this + */ + public function setTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->time_unix_nano = $var; + + return $this; + } + + /** + * count is the number of values in the population. Must be non-negative. This + * value must be equal to the sum of the "count" fields in buckets if a + * histogram is provided. + * + * Generated from protobuf field fixed64 count = 4; + * @return int|string + */ + public function getCount() + { + return $this->count; + } + + /** + * count is the number of values in the population. Must be non-negative. This + * value must be equal to the sum of the "count" fields in buckets if a + * histogram is provided. + * + * Generated from protobuf field fixed64 count = 4; + * @param int|string $var + * @return $this + */ + public function setCount($var) + { + GPBUtil::checkUint64($var); + $this->count = $var; + + return $this; + } + + /** + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram + * + * Generated from protobuf field optional double sum = 5; + * @return float + */ + public function getSum() + { + return isset($this->sum) ? $this->sum : 0.0; + } + + public function hasSum() + { + return isset($this->sum); + } + + public function clearSum() + { + unset($this->sum); + } + + /** + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram + * + * Generated from protobuf field optional double sum = 5; + * @param float $var + * @return $this + */ + public function setSum($var) + { + GPBUtil::checkDouble($var); + $this->sum = $var; + + return $this; + } + + /** + * bucket_counts is an optional field contains the count values of histogram + * for each bucket. + * The sum of the bucket_counts must equal the value in the count field. + * The number of elements in bucket_counts array must be by one greater than + * the number of elements in explicit_bounds array. + * + * Generated from protobuf field repeated fixed64 bucket_counts = 6; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getBucketCounts() + { + return $this->bucket_counts; + } + + /** + * bucket_counts is an optional field contains the count values of histogram + * for each bucket. + * The sum of the bucket_counts must equal the value in the count field. + * The number of elements in bucket_counts array must be by one greater than + * the number of elements in explicit_bounds array. + * + * Generated from protobuf field repeated fixed64 bucket_counts = 6; + * @param int[]|string[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setBucketCounts($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::FIXED64); + $this->bucket_counts = $arr; + + return $this; + } + + /** + * explicit_bounds specifies buckets with explicitly defined bounds for values. + * The boundaries for bucket at index i are: + * (-infinity, explicit_bounds[i]] for i == 0 + * (explicit_bounds[i-1], explicit_bounds[i]] for 0 < i < size(explicit_bounds) + * (explicit_bounds[i-1], +infinity) for i == size(explicit_bounds) + * The values in the explicit_bounds array must be strictly increasing. + * Histogram buckets are inclusive of their upper boundary, except the last + * bucket where the boundary is at infinity. This format is intentionally + * compatible with the OpenMetrics histogram definition. + * + * Generated from protobuf field repeated double explicit_bounds = 7; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getExplicitBounds() + { + return $this->explicit_bounds; + } + + /** + * explicit_bounds specifies buckets with explicitly defined bounds for values. + * The boundaries for bucket at index i are: + * (-infinity, explicit_bounds[i]] for i == 0 + * (explicit_bounds[i-1], explicit_bounds[i]] for 0 < i < size(explicit_bounds) + * (explicit_bounds[i-1], +infinity) for i == size(explicit_bounds) + * The values in the explicit_bounds array must be strictly increasing. + * Histogram buckets are inclusive of their upper boundary, except the last + * bucket where the boundary is at infinity. This format is intentionally + * compatible with the OpenMetrics histogram definition. + * + * Generated from protobuf field repeated double explicit_bounds = 7; + * @param float[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setExplicitBounds($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::DOUBLE); + $this->explicit_bounds = $arr; + + return $this; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 8; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getExemplars() + { + return $this->exemplars; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 8; + * @param \Opentelemetry\Proto\Metrics\V1\Exemplar[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setExemplars($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\Exemplar::class); + $this->exemplars = $arr; + + return $this; + } + + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 10; + * @return int + */ + public function getFlags() + { + return $this->flags; + } + + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 10; + * @param int $var + * @return $this + */ + public function setFlags($var) + { + GPBUtil::checkUint32($var); + $this->flags = $var; + + return $this; + } + + /** + * min is the minimum value over (start_time, end_time]. + * + * Generated from protobuf field optional double min = 11; + * @return float + */ + public function getMin() + { + return isset($this->min) ? $this->min : 0.0; + } + + public function hasMin() + { + return isset($this->min); + } + + public function clearMin() + { + unset($this->min); + } + + /** + * min is the minimum value over (start_time, end_time]. + * + * Generated from protobuf field optional double min = 11; + * @param float $var + * @return $this + */ + public function setMin($var) + { + GPBUtil::checkDouble($var); + $this->min = $var; + + return $this; + } + + /** + * max is the maximum value over (start_time, end_time]. + * + * Generated from protobuf field optional double max = 12; + * @return float + */ + public function getMax() + { + return isset($this->max) ? $this->max : 0.0; + } + + public function hasMax() + { + return isset($this->max); + } + + public function clearMax() + { + unset($this->max); + } + + /** + * max is the maximum value over (start_time, end_time]. + * + * Generated from protobuf field optional double max = 12; + * @param float $var + * @return $this + */ + public function setMax($var) + { + GPBUtil::checkDouble($var); + $this->max = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/InstrumentationLibraryMetrics.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/InstrumentationLibraryMetrics.php new file mode 100644 index 000000000..807aa1054 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/InstrumentationLibraryMetrics.php @@ -0,0 +1,156 @@ +opentelemetry.proto.metrics.v1.InstrumentationLibraryMetrics + */ +class InstrumentationLibraryMetrics extends \Google\Protobuf\Internal\Message +{ + /** + * The instrumentation library information for the metrics in this message. + * Semantically when InstrumentationLibrary isn't set, it is equivalent with + * an empty instrumentation library name (unknown). + * + * Generated from protobuf field .opentelemetry.proto.common.v1.InstrumentationLibrary instrumentation_library = 1; + */ + protected $instrumentation_library = null; + /** + * A list of metrics that originate from an instrumentation library. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Metric metrics = 2; + */ + private $metrics; + /** + * This schema_url applies to all metrics in the "metrics" field. + * + * Generated from protobuf field string schema_url = 3; + */ + protected $schema_url = ''; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\InstrumentationLibrary $instrumentation_library + * The instrumentation library information for the metrics in this message. + * Semantically when InstrumentationLibrary isn't set, it is equivalent with + * an empty instrumentation library name (unknown). + * @type \Opentelemetry\Proto\Metrics\V1\Metric[]|\Google\Protobuf\Internal\RepeatedField $metrics + * A list of metrics that originate from an instrumentation library. + * @type string $schema_url + * This schema_url applies to all metrics in the "metrics" field. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The instrumentation library information for the metrics in this message. + * Semantically when InstrumentationLibrary isn't set, it is equivalent with + * an empty instrumentation library name (unknown). + * + * Generated from protobuf field .opentelemetry.proto.common.v1.InstrumentationLibrary instrumentation_library = 1; + * @return \Opentelemetry\Proto\Common\V1\InstrumentationLibrary|null + */ + public function getInstrumentationLibrary() + { + return $this->instrumentation_library; + } + + public function hasInstrumentationLibrary() + { + return isset($this->instrumentation_library); + } + + public function clearInstrumentationLibrary() + { + unset($this->instrumentation_library); + } + + /** + * The instrumentation library information for the metrics in this message. + * Semantically when InstrumentationLibrary isn't set, it is equivalent with + * an empty instrumentation library name (unknown). + * + * Generated from protobuf field .opentelemetry.proto.common.v1.InstrumentationLibrary instrumentation_library = 1; + * @param \Opentelemetry\Proto\Common\V1\InstrumentationLibrary $var + * @return $this + */ + public function setInstrumentationLibrary($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Common\V1\InstrumentationLibrary::class); + $this->instrumentation_library = $var; + + return $this; + } + + /** + * A list of metrics that originate from an instrumentation library. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Metric metrics = 2; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getMetrics() + { + return $this->metrics; + } + + /** + * A list of metrics that originate from an instrumentation library. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Metric metrics = 2; + * @param \Opentelemetry\Proto\Metrics\V1\Metric[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setMetrics($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\Metric::class); + $this->metrics = $arr; + + return $this; + } + + /** + * This schema_url applies to all metrics in the "metrics" field. + * + * Generated from protobuf field string schema_url = 3; + * @return string + */ + public function getSchemaUrl() + { + return $this->schema_url; + } + + /** + * This schema_url applies to all metrics in the "metrics" field. + * + * Generated from protobuf field string schema_url = 3; + * @param string $var + * @return $this + */ + public function setSchemaUrl($var) + { + GPBUtil::checkString($var, True); + $this->schema_url = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntDataPoint.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntDataPoint.php new file mode 100644 index 000000000..2eac03fcb --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntDataPoint.php @@ -0,0 +1,227 @@ +opentelemetry.proto.metrics.v1.IntDataPoint + */ +class IntDataPoint extends \Google\Protobuf\Internal\Message +{ + /** + * The set of labels that uniquely identify this timeseries. + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1; + */ + private $labels; + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + */ + protected $start_time_unix_nano = 0; + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + */ + protected $time_unix_nano = 0; + /** + * value itself. + * + * Generated from protobuf field sfixed64 value = 4; + */ + protected $value = 0; + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntExemplar exemplars = 5; + */ + private $exemplars; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\StringKeyValue[]|\Google\Protobuf\Internal\RepeatedField $labels + * The set of labels that uniquely identify this timeseries. + * @type int|string $start_time_unix_nano + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $time_unix_nano + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $value + * value itself. + * @type \Opentelemetry\Proto\Metrics\V1\IntExemplar[]|\Google\Protobuf\Internal\RepeatedField $exemplars + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The set of labels that uniquely identify this timeseries. + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getLabels() + { + return $this->labels; + } + + /** + * The set of labels that uniquely identify this timeseries. + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1; + * @param \Opentelemetry\Proto\Common\V1\StringKeyValue[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setLabels($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Common\V1\StringKeyValue::class); + $this->labels = $arr; + + return $this; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @return int|string + */ + public function getStartTimeUnixNano() + { + return $this->start_time_unix_nano; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @param int|string $var + * @return $this + */ + public function setStartTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->start_time_unix_nano = $var; + + return $this; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @return int|string + */ + public function getTimeUnixNano() + { + return $this->time_unix_nano; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @param int|string $var + * @return $this + */ + public function setTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->time_unix_nano = $var; + + return $this; + } + + /** + * value itself. + * + * Generated from protobuf field sfixed64 value = 4; + * @return int|string + */ + public function getValue() + { + return $this->value; + } + + /** + * value itself. + * + * Generated from protobuf field sfixed64 value = 4; + * @param int|string $var + * @return $this + */ + public function setValue($var) + { + GPBUtil::checkInt64($var); + $this->value = $var; + + return $this; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntExemplar exemplars = 5; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getExemplars() + { + return $this->exemplars; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntExemplar exemplars = 5; + * @param \Opentelemetry\Proto\Metrics\V1\IntExemplar[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setExemplars($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\IntExemplar::class); + $this->exemplars = $arr; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntExemplar.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntExemplar.php new file mode 100644 index 000000000..319c0ff27 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntExemplar.php @@ -0,0 +1,235 @@ +opentelemetry.proto.metrics.v1.IntExemplar + */ +class IntExemplar extends \Google\Protobuf\Internal\Message +{ + /** + * The set of labels that were filtered out by the aggregator, but recorded + * alongside the original measurement. Only labels that were filtered out + * by the aggregator should be included + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.StringKeyValue filtered_labels = 1; + */ + private $filtered_labels; + /** + * time_unix_nano is the exact time when this exemplar was recorded + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 2; + */ + protected $time_unix_nano = 0; + /** + * Numerical int value of the measurement that was recorded. + * + * Generated from protobuf field sfixed64 value = 3; + */ + protected $value = 0; + /** + * (Optional) Span ID of the exemplar trace. + * span_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes span_id = 4; + */ + protected $span_id = ''; + /** + * (Optional) Trace ID of the exemplar trace. + * trace_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes trace_id = 5; + */ + protected $trace_id = ''; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\StringKeyValue[]|\Google\Protobuf\Internal\RepeatedField $filtered_labels + * The set of labels that were filtered out by the aggregator, but recorded + * alongside the original measurement. Only labels that were filtered out + * by the aggregator should be included + * @type int|string $time_unix_nano + * time_unix_nano is the exact time when this exemplar was recorded + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $value + * Numerical int value of the measurement that was recorded. + * @type string $span_id + * (Optional) Span ID of the exemplar trace. + * span_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * @type string $trace_id + * (Optional) Trace ID of the exemplar trace. + * trace_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The set of labels that were filtered out by the aggregator, but recorded + * alongside the original measurement. Only labels that were filtered out + * by the aggregator should be included + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.StringKeyValue filtered_labels = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getFilteredLabels() + { + return $this->filtered_labels; + } + + /** + * The set of labels that were filtered out by the aggregator, but recorded + * alongside the original measurement. Only labels that were filtered out + * by the aggregator should be included + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.StringKeyValue filtered_labels = 1; + * @param \Opentelemetry\Proto\Common\V1\StringKeyValue[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setFilteredLabels($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Common\V1\StringKeyValue::class); + $this->filtered_labels = $arr; + + return $this; + } + + /** + * time_unix_nano is the exact time when this exemplar was recorded + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 2; + * @return int|string + */ + public function getTimeUnixNano() + { + return $this->time_unix_nano; + } + + /** + * time_unix_nano is the exact time when this exemplar was recorded + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 2; + * @param int|string $var + * @return $this + */ + public function setTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->time_unix_nano = $var; + + return $this; + } + + /** + * Numerical int value of the measurement that was recorded. + * + * Generated from protobuf field sfixed64 value = 3; + * @return int|string + */ + public function getValue() + { + return $this->value; + } + + /** + * Numerical int value of the measurement that was recorded. + * + * Generated from protobuf field sfixed64 value = 3; + * @param int|string $var + * @return $this + */ + public function setValue($var) + { + GPBUtil::checkInt64($var); + $this->value = $var; + + return $this; + } + + /** + * (Optional) Span ID of the exemplar trace. + * span_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes span_id = 4; + * @return string + */ + public function getSpanId() + { + return $this->span_id; + } + + /** + * (Optional) Span ID of the exemplar trace. + * span_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes span_id = 4; + * @param string $var + * @return $this + */ + public function setSpanId($var) + { + GPBUtil::checkString($var, False); + $this->span_id = $var; + + return $this; + } + + /** + * (Optional) Trace ID of the exemplar trace. + * trace_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes trace_id = 5; + * @return string + */ + public function getTraceId() + { + return $this->trace_id; + } + + /** + * (Optional) Trace ID of the exemplar trace. + * trace_id may be missing if the measurement is not recorded inside a trace + * or if the trace is not sampled. + * + * Generated from protobuf field bytes trace_id = 5; + * @param string $var + * @return $this + */ + public function setTraceId($var) + { + GPBUtil::checkString($var, False); + $this->trace_id = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntGauge.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntGauge.php new file mode 100644 index 000000000..37fece6dd --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntGauge.php @@ -0,0 +1,60 @@ +opentelemetry.proto.metrics.v1.IntGauge + */ +class IntGauge extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntDataPoint data_points = 1; + */ + private $data_points; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\V1\IntDataPoint[]|\Google\Protobuf\Internal\RepeatedField $data_points + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntDataPoint data_points = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getDataPoints() + { + return $this->data_points; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntDataPoint data_points = 1; + * @param \Opentelemetry\Proto\Metrics\V1\IntDataPoint[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setDataPoints($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\IntDataPoint::class); + $this->data_points = $arr; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntHistogram.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntHistogram.php new file mode 100644 index 000000000..934649310 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntHistogram.php @@ -0,0 +1,99 @@ +opentelemetry.proto.metrics.v1.IntHistogram + */ +class IntHistogram extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntHistogramDataPoint data_points = 1; + */ + private $data_points; + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + */ + protected $aggregation_temporality = 0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\V1\IntHistogramDataPoint[]|\Google\Protobuf\Internal\RepeatedField $data_points + * @type int $aggregation_temporality + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntHistogramDataPoint data_points = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getDataPoints() + { + return $this->data_points; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntHistogramDataPoint data_points = 1; + * @param \Opentelemetry\Proto\Metrics\V1\IntHistogramDataPoint[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setDataPoints($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\IntHistogramDataPoint::class); + $this->data_points = $arr; + + return $this; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @return int + */ + public function getAggregationTemporality() + { + return $this->aggregation_temporality; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @param int $var + * @return $this + */ + public function setAggregationTemporality($var) + { + GPBUtil::checkEnum($var, \Opentelemetry\Proto\Metrics\V1\AggregationTemporality::class); + $this->aggregation_temporality = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntHistogramDataPoint.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntHistogramDataPoint.php new file mode 100644 index 000000000..cf0e4898b --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntHistogramDataPoint.php @@ -0,0 +1,393 @@ +opentelemetry.proto.metrics.v1.IntHistogramDataPoint + */ +class IntHistogramDataPoint extends \Google\Protobuf\Internal\Message +{ + /** + * The set of labels that uniquely identify this timeseries. + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1; + */ + private $labels; + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + */ + protected $start_time_unix_nano = 0; + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + */ + protected $time_unix_nano = 0; + /** + * count is the number of values in the population. Must be non-negative. This + * value must be equal to the sum of the "count" fields in buckets if a + * histogram is provided. + * + * Generated from protobuf field fixed64 count = 4; + */ + protected $count = 0; + /** + * sum of the values in the population. If count is zero then this field + * must be zero. This value must be equal to the sum of the "sum" fields in + * buckets if a histogram is provided. + * + * Generated from protobuf field sfixed64 sum = 5; + */ + protected $sum = 0; + /** + * bucket_counts is an optional field contains the count values of histogram + * for each bucket. + * The sum of the bucket_counts must equal the value in the count field. + * The number of elements in bucket_counts array must be by one greater than + * the number of elements in explicit_bounds array. + * + * Generated from protobuf field repeated fixed64 bucket_counts = 6; + */ + private $bucket_counts; + /** + * explicit_bounds specifies buckets with explicitly defined bounds for values. + * The boundaries for bucket at index i are: + * (-infinity, explicit_bounds[i]] for i == 0 + * (explicit_bounds[i-1], explicit_bounds[i]] for 0 < i < size(explicit_bounds) + * (explicit_bounds[i-1], +infinity) for i == size(explicit_bounds) + * The values in the explicit_bounds array must be strictly increasing. + * Histogram buckets are inclusive of their upper boundary, except the last + * bucket where the boundary is at infinity. This format is intentionally + * compatible with the OpenMetrics histogram definition. + * + * Generated from protobuf field repeated double explicit_bounds = 7; + */ + private $explicit_bounds; + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntExemplar exemplars = 8; + */ + private $exemplars; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\StringKeyValue[]|\Google\Protobuf\Internal\RepeatedField $labels + * The set of labels that uniquely identify this timeseries. + * @type int|string $start_time_unix_nano + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $time_unix_nano + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $count + * count is the number of values in the population. Must be non-negative. This + * value must be equal to the sum of the "count" fields in buckets if a + * histogram is provided. + * @type int|string $sum + * sum of the values in the population. If count is zero then this field + * must be zero. This value must be equal to the sum of the "sum" fields in + * buckets if a histogram is provided. + * @type int[]|string[]|\Google\Protobuf\Internal\RepeatedField $bucket_counts + * bucket_counts is an optional field contains the count values of histogram + * for each bucket. + * The sum of the bucket_counts must equal the value in the count field. + * The number of elements in bucket_counts array must be by one greater than + * the number of elements in explicit_bounds array. + * @type float[]|\Google\Protobuf\Internal\RepeatedField $explicit_bounds + * explicit_bounds specifies buckets with explicitly defined bounds for values. + * The boundaries for bucket at index i are: + * (-infinity, explicit_bounds[i]] for i == 0 + * (explicit_bounds[i-1], explicit_bounds[i]] for 0 < i < size(explicit_bounds) + * (explicit_bounds[i-1], +infinity) for i == size(explicit_bounds) + * The values in the explicit_bounds array must be strictly increasing. + * Histogram buckets are inclusive of their upper boundary, except the last + * bucket where the boundary is at infinity. This format is intentionally + * compatible with the OpenMetrics histogram definition. + * @type \Opentelemetry\Proto\Metrics\V1\IntExemplar[]|\Google\Protobuf\Internal\RepeatedField $exemplars + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The set of labels that uniquely identify this timeseries. + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getLabels() + { + return $this->labels; + } + + /** + * The set of labels that uniquely identify this timeseries. + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.StringKeyValue labels = 1; + * @param \Opentelemetry\Proto\Common\V1\StringKeyValue[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setLabels($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Common\V1\StringKeyValue::class); + $this->labels = $arr; + + return $this; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @return int|string + */ + public function getStartTimeUnixNano() + { + return $this->start_time_unix_nano; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @param int|string $var + * @return $this + */ + public function setStartTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->start_time_unix_nano = $var; + + return $this; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @return int|string + */ + public function getTimeUnixNano() + { + return $this->time_unix_nano; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @param int|string $var + * @return $this + */ + public function setTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->time_unix_nano = $var; + + return $this; + } + + /** + * count is the number of values in the population. Must be non-negative. This + * value must be equal to the sum of the "count" fields in buckets if a + * histogram is provided. + * + * Generated from protobuf field fixed64 count = 4; + * @return int|string + */ + public function getCount() + { + return $this->count; + } + + /** + * count is the number of values in the population. Must be non-negative. This + * value must be equal to the sum of the "count" fields in buckets if a + * histogram is provided. + * + * Generated from protobuf field fixed64 count = 4; + * @param int|string $var + * @return $this + */ + public function setCount($var) + { + GPBUtil::checkUint64($var); + $this->count = $var; + + return $this; + } + + /** + * sum of the values in the population. If count is zero then this field + * must be zero. This value must be equal to the sum of the "sum" fields in + * buckets if a histogram is provided. + * + * Generated from protobuf field sfixed64 sum = 5; + * @return int|string + */ + public function getSum() + { + return $this->sum; + } + + /** + * sum of the values in the population. If count is zero then this field + * must be zero. This value must be equal to the sum of the "sum" fields in + * buckets if a histogram is provided. + * + * Generated from protobuf field sfixed64 sum = 5; + * @param int|string $var + * @return $this + */ + public function setSum($var) + { + GPBUtil::checkInt64($var); + $this->sum = $var; + + return $this; + } + + /** + * bucket_counts is an optional field contains the count values of histogram + * for each bucket. + * The sum of the bucket_counts must equal the value in the count field. + * The number of elements in bucket_counts array must be by one greater than + * the number of elements in explicit_bounds array. + * + * Generated from protobuf field repeated fixed64 bucket_counts = 6; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getBucketCounts() + { + return $this->bucket_counts; + } + + /** + * bucket_counts is an optional field contains the count values of histogram + * for each bucket. + * The sum of the bucket_counts must equal the value in the count field. + * The number of elements in bucket_counts array must be by one greater than + * the number of elements in explicit_bounds array. + * + * Generated from protobuf field repeated fixed64 bucket_counts = 6; + * @param int[]|string[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setBucketCounts($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::FIXED64); + $this->bucket_counts = $arr; + + return $this; + } + + /** + * explicit_bounds specifies buckets with explicitly defined bounds for values. + * The boundaries for bucket at index i are: + * (-infinity, explicit_bounds[i]] for i == 0 + * (explicit_bounds[i-1], explicit_bounds[i]] for 0 < i < size(explicit_bounds) + * (explicit_bounds[i-1], +infinity) for i == size(explicit_bounds) + * The values in the explicit_bounds array must be strictly increasing. + * Histogram buckets are inclusive of their upper boundary, except the last + * bucket where the boundary is at infinity. This format is intentionally + * compatible with the OpenMetrics histogram definition. + * + * Generated from protobuf field repeated double explicit_bounds = 7; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getExplicitBounds() + { + return $this->explicit_bounds; + } + + /** + * explicit_bounds specifies buckets with explicitly defined bounds for values. + * The boundaries for bucket at index i are: + * (-infinity, explicit_bounds[i]] for i == 0 + * (explicit_bounds[i-1], explicit_bounds[i]] for 0 < i < size(explicit_bounds) + * (explicit_bounds[i-1], +infinity) for i == size(explicit_bounds) + * The values in the explicit_bounds array must be strictly increasing. + * Histogram buckets are inclusive of their upper boundary, except the last + * bucket where the boundary is at infinity. This format is intentionally + * compatible with the OpenMetrics histogram definition. + * + * Generated from protobuf field repeated double explicit_bounds = 7; + * @param float[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setExplicitBounds($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::DOUBLE); + $this->explicit_bounds = $arr; + + return $this; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntExemplar exemplars = 8; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getExemplars() + { + return $this->exemplars; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntExemplar exemplars = 8; + * @param \Opentelemetry\Proto\Metrics\V1\IntExemplar[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setExemplars($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\IntExemplar::class); + $this->exemplars = $arr; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntSum.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntSum.php new file mode 100644 index 000000000..aaa313d7d --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/IntSum.php @@ -0,0 +1,132 @@ +opentelemetry.proto.metrics.v1.IntSum + */ +class IntSum extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntDataPoint data_points = 1; + */ + private $data_points; + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + */ + protected $aggregation_temporality = 0; + /** + * If "true" means that the sum is monotonic. + * + * Generated from protobuf field bool is_monotonic = 3; + */ + protected $is_monotonic = false; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\V1\IntDataPoint[]|\Google\Protobuf\Internal\RepeatedField $data_points + * @type int $aggregation_temporality + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * @type bool $is_monotonic + * If "true" means that the sum is monotonic. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntDataPoint data_points = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getDataPoints() + { + return $this->data_points; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.IntDataPoint data_points = 1; + * @param \Opentelemetry\Proto\Metrics\V1\IntDataPoint[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setDataPoints($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\IntDataPoint::class); + $this->data_points = $arr; + + return $this; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @return int + */ + public function getAggregationTemporality() + { + return $this->aggregation_temporality; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @param int $var + * @return $this + */ + public function setAggregationTemporality($var) + { + GPBUtil::checkEnum($var, \Opentelemetry\Proto\Metrics\V1\AggregationTemporality::class); + $this->aggregation_temporality = $var; + + return $this; + } + + /** + * If "true" means that the sum is monotonic. + * + * Generated from protobuf field bool is_monotonic = 3; + * @return bool + */ + public function getIsMonotonic() + { + return $this->is_monotonic; + } + + /** + * If "true" means that the sum is monotonic. + * + * Generated from protobuf field bool is_monotonic = 3; + * @param bool $var + * @return $this + */ + public function setIsMonotonic($var) + { + GPBUtil::checkBool($var); + $this->is_monotonic = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Metric.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Metric.php new file mode 100644 index 000000000..3d2538314 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Metric.php @@ -0,0 +1,358 @@ + |Gauge, Sum, Histogram, Summary, ... | + * +------------+ +------------------------------------+ + * Data [One of Gauge, Sum, Histogram, Summary, ...] + * +-----------+ + * |... | // Metadata about the Data. + * |points |--+ + * +-----------+ | + * | +---------------------------+ + * | |DataPoint 1 | + * v |+------+------+ +------+ | + * +-----+ ||label |label |...|label | | + * | 1 |-->||value1|value2|...|valueN| | + * +-----+ |+------+------+ +------+ | + * | . | |+-----+ | + * | . | ||value| | + * | . | |+-----+ | + * | . | +---------------------------+ + * | . | . + * | . | . + * | . | . + * | . | +---------------------------+ + * | . | |DataPoint M | + * +-----+ |+------+------+ +------+ | + * | M |-->||label |label |...|label | | + * +-----+ ||value1|value2|...|valueN| | + * |+------+------+ +------+ | + * |+-----+ | + * ||value| | + * |+-----+ | + * +---------------------------+ + * Each distinct type of DataPoint represents the output of a specific + * aggregation function, the result of applying the DataPoint's + * associated function of to one or more measurements. + * All DataPoint types have three common fields: + * - Attributes includes key-value pairs associated with the data point + * - TimeUnixNano is required, set to the end time of the aggregation + * - StartTimeUnixNano is optional, but strongly encouraged for DataPoints + * having an AggregationTemporality field, as discussed below. + * Both TimeUnixNano and StartTimeUnixNano values are expressed as + * UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. + * # TimeUnixNano + * This field is required, having consistent interpretation across + * DataPoint types. TimeUnixNano is the moment corresponding to when + * the data point's aggregate value was captured. + * Data points with the 0 value for TimeUnixNano SHOULD be rejected + * by consumers. + * # StartTimeUnixNano + * StartTimeUnixNano in general allows detecting when a sequence of + * observations is unbroken. This field indicates to consumers the + * start time for points with cumulative and delta + * AggregationTemporality, and it should be included whenever possible + * to support correct rate calculation. Although it may be omitted + * when the start time is truly unknown, setting StartTimeUnixNano is + * strongly encouraged. + * + * Generated from protobuf message opentelemetry.proto.metrics.v1.Metric + */ +class Metric extends \Google\Protobuf\Internal\Message +{ + /** + * name of the metric, including its DNS name prefix. It must be unique. + * + * Generated from protobuf field string name = 1; + */ + protected $name = ''; + /** + * description of the metric, which can be used in documentation. + * + * Generated from protobuf field string description = 2; + */ + protected $description = ''; + /** + * unit in which the metric value is reported. Follows the format + * described by http://unitsofmeasure.org/ucum.html. + * + * Generated from protobuf field string unit = 3; + */ + protected $unit = ''; + protected $data; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type string $name + * name of the metric, including its DNS name prefix. It must be unique. + * @type string $description + * description of the metric, which can be used in documentation. + * @type string $unit + * unit in which the metric value is reported. Follows the format + * described by http://unitsofmeasure.org/ucum.html. + * @type \Opentelemetry\Proto\Metrics\V1\Gauge $gauge + * @type \Opentelemetry\Proto\Metrics\V1\Sum $sum + * @type \Opentelemetry\Proto\Metrics\V1\Histogram $histogram + * @type \Opentelemetry\Proto\Metrics\V1\ExponentialHistogram $exponential_histogram + * @type \Opentelemetry\Proto\Metrics\V1\Summary $summary + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * name of the metric, including its DNS name prefix. It must be unique. + * + * Generated from protobuf field string name = 1; + * @return string + */ + public function getName() + { + return $this->name; + } + + /** + * name of the metric, including its DNS name prefix. It must be unique. + * + * Generated from protobuf field string name = 1; + * @param string $var + * @return $this + */ + public function setName($var) + { + GPBUtil::checkString($var, True); + $this->name = $var; + + return $this; + } + + /** + * description of the metric, which can be used in documentation. + * + * Generated from protobuf field string description = 2; + * @return string + */ + public function getDescription() + { + return $this->description; + } + + /** + * description of the metric, which can be used in documentation. + * + * Generated from protobuf field string description = 2; + * @param string $var + * @return $this + */ + public function setDescription($var) + { + GPBUtil::checkString($var, True); + $this->description = $var; + + return $this; + } + + /** + * unit in which the metric value is reported. Follows the format + * described by http://unitsofmeasure.org/ucum.html. + * + * Generated from protobuf field string unit = 3; + * @return string + */ + public function getUnit() + { + return $this->unit; + } + + /** + * unit in which the metric value is reported. Follows the format + * described by http://unitsofmeasure.org/ucum.html. + * + * Generated from protobuf field string unit = 3; + * @param string $var + * @return $this + */ + public function setUnit($var) + { + GPBUtil::checkString($var, True); + $this->unit = $var; + + return $this; + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.Gauge gauge = 5; + * @return \Opentelemetry\Proto\Metrics\V1\Gauge|null + */ + public function getGauge() + { + return $this->readOneof(5); + } + + public function hasGauge() + { + return $this->hasOneof(5); + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.Gauge gauge = 5; + * @param \Opentelemetry\Proto\Metrics\V1\Gauge $var + * @return $this + */ + public function setGauge($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Metrics\V1\Gauge::class); + $this->writeOneof(5, $var); + + return $this; + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.Sum sum = 7; + * @return \Opentelemetry\Proto\Metrics\V1\Sum|null + */ + public function getSum() + { + return $this->readOneof(7); + } + + public function hasSum() + { + return $this->hasOneof(7); + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.Sum sum = 7; + * @param \Opentelemetry\Proto\Metrics\V1\Sum $var + * @return $this + */ + public function setSum($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Metrics\V1\Sum::class); + $this->writeOneof(7, $var); + + return $this; + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.Histogram histogram = 9; + * @return \Opentelemetry\Proto\Metrics\V1\Histogram|null + */ + public function getHistogram() + { + return $this->readOneof(9); + } + + public function hasHistogram() + { + return $this->hasOneof(9); + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.Histogram histogram = 9; + * @param \Opentelemetry\Proto\Metrics\V1\Histogram $var + * @return $this + */ + public function setHistogram($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Metrics\V1\Histogram::class); + $this->writeOneof(9, $var); + + return $this; + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.ExponentialHistogram exponential_histogram = 10; + * @return \Opentelemetry\Proto\Metrics\V1\ExponentialHistogram|null + */ + public function getExponentialHistogram() + { + return $this->readOneof(10); + } + + public function hasExponentialHistogram() + { + return $this->hasOneof(10); + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.ExponentialHistogram exponential_histogram = 10; + * @param \Opentelemetry\Proto\Metrics\V1\ExponentialHistogram $var + * @return $this + */ + public function setExponentialHistogram($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Metrics\V1\ExponentialHistogram::class); + $this->writeOneof(10, $var); + + return $this; + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.Summary summary = 11; + * @return \Opentelemetry\Proto\Metrics\V1\Summary|null + */ + public function getSummary() + { + return $this->readOneof(11); + } + + public function hasSummary() + { + return $this->hasOneof(11); + } + + /** + * Generated from protobuf field .opentelemetry.proto.metrics.v1.Summary summary = 11; + * @param \Opentelemetry\Proto\Metrics\V1\Summary $var + * @return $this + */ + public function setSummary($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Metrics\V1\Summary::class); + $this->writeOneof(11, $var); + + return $this; + } + + /** + * @return string + */ + public function getData() + { + return $this->whichOneof("data"); + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/MetricsData.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/MetricsData.php new file mode 100644 index 000000000..ce144d8f3 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/MetricsData.php @@ -0,0 +1,90 @@ +opentelemetry.proto.metrics.v1.MetricsData + */ +class MetricsData extends \Google\Protobuf\Internal\Message +{ + /** + * An array of ResourceMetrics. + * For data coming from a single resource this array will typically contain + * one element. Intermediary nodes that receive data from multiple origins + * typically batch the data before forwarding further and in that case this + * array will contain multiple elements. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.ResourceMetrics resource_metrics = 1; + */ + private $resource_metrics; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\V1\ResourceMetrics[]|\Google\Protobuf\Internal\RepeatedField $resource_metrics + * An array of ResourceMetrics. + * For data coming from a single resource this array will typically contain + * one element. Intermediary nodes that receive data from multiple origins + * typically batch the data before forwarding further and in that case this + * array will contain multiple elements. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * An array of ResourceMetrics. + * For data coming from a single resource this array will typically contain + * one element. Intermediary nodes that receive data from multiple origins + * typically batch the data before forwarding further and in that case this + * array will contain multiple elements. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.ResourceMetrics resource_metrics = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getResourceMetrics() + { + return $this->resource_metrics; + } + + /** + * An array of ResourceMetrics. + * For data coming from a single resource this array will typically contain + * one element. Intermediary nodes that receive data from multiple origins + * typically batch the data before forwarding further and in that case this + * array will contain multiple elements. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.ResourceMetrics resource_metrics = 1; + * @param \Opentelemetry\Proto\Metrics\V1\ResourceMetrics[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setResourceMetrics($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\ResourceMetrics::class); + $this->resource_metrics = $arr; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/NumberDataPoint.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/NumberDataPoint.php new file mode 100644 index 000000000..d9fa829e0 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/NumberDataPoint.php @@ -0,0 +1,309 @@ +opentelemetry.proto.metrics.v1.NumberDataPoint + */ +class NumberDataPoint extends \Google\Protobuf\Internal\Message +{ + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 7; + */ + private $attributes; + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + */ + protected $start_time_unix_nano = 0; + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + */ + protected $time_unix_nano = 0; + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 5; + */ + private $exemplars; + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 8; + */ + protected $flags = 0; + protected $value; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $attributes + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * @type int|string $start_time_unix_nano + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $time_unix_nano + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type float $as_double + * @type int|string $as_int + * @type \Opentelemetry\Proto\Metrics\V1\Exemplar[]|\Google\Protobuf\Internal\RepeatedField $exemplars + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * @type int $flags + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 7; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getAttributes() + { + return $this->attributes; + } + + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 7; + * @param \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setAttributes($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Common\V1\KeyValue::class); + $this->attributes = $arr; + + return $this; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @return int|string + */ + public function getStartTimeUnixNano() + { + return $this->start_time_unix_nano; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @param int|string $var + * @return $this + */ + public function setStartTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->start_time_unix_nano = $var; + + return $this; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @return int|string + */ + public function getTimeUnixNano() + { + return $this->time_unix_nano; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @param int|string $var + * @return $this + */ + public function setTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->time_unix_nano = $var; + + return $this; + } + + /** + * Generated from protobuf field double as_double = 4; + * @return float + */ + public function getAsDouble() + { + return $this->readOneof(4); + } + + public function hasAsDouble() + { + return $this->hasOneof(4); + } + + /** + * Generated from protobuf field double as_double = 4; + * @param float $var + * @return $this + */ + public function setAsDouble($var) + { + GPBUtil::checkDouble($var); + $this->writeOneof(4, $var); + + return $this; + } + + /** + * Generated from protobuf field sfixed64 as_int = 6; + * @return int|string + */ + public function getAsInt() + { + return $this->readOneof(6); + } + + public function hasAsInt() + { + return $this->hasOneof(6); + } + + /** + * Generated from protobuf field sfixed64 as_int = 6; + * @param int|string $var + * @return $this + */ + public function setAsInt($var) + { + GPBUtil::checkInt64($var); + $this->writeOneof(6, $var); + + return $this; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 5; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getExemplars() + { + return $this->exemplars; + } + + /** + * (Optional) List of exemplars collected from + * measurements that were used to form the data point + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Exemplar exemplars = 5; + * @param \Opentelemetry\Proto\Metrics\V1\Exemplar[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setExemplars($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\Exemplar::class); + $this->exemplars = $arr; + + return $this; + } + + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 8; + * @return int + */ + public function getFlags() + { + return $this->flags; + } + + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 8; + * @param int $var + * @return $this + */ + public function setFlags($var) + { + GPBUtil::checkUint32($var); + $this->flags = $var; + + return $this; + } + + /** + * @return string + */ + public function getValue() + { + return $this->whichOneof("value"); + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ResourceMetrics.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ResourceMetrics.php new file mode 100644 index 000000000..a5e2a7b0d --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ResourceMetrics.php @@ -0,0 +1,153 @@ +opentelemetry.proto.metrics.v1.ResourceMetrics + */ +class ResourceMetrics extends \Google\Protobuf\Internal\Message +{ + /** + * The resource for the metrics in this message. + * If this field is not set then no resource info is known. + * + * Generated from protobuf field .opentelemetry.proto.resource.v1.Resource resource = 1; + */ + protected $resource = null; + /** + * A list of metrics that originate from a resource. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.ScopeMetrics scope_metrics = 2; + */ + private $scope_metrics; + /** + * This schema_url applies to the data in the "resource" field. It does not apply + * to the data in the "scope_metrics" field which have their own schema_url field. + * + * Generated from protobuf field string schema_url = 3; + */ + protected $schema_url = ''; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Resource\V1\Resource $resource + * The resource for the metrics in this message. + * If this field is not set then no resource info is known. + * @type \Opentelemetry\Proto\Metrics\V1\ScopeMetrics[]|\Google\Protobuf\Internal\RepeatedField $scope_metrics + * A list of metrics that originate from a resource. + * @type string $schema_url + * This schema_url applies to the data in the "resource" field. It does not apply + * to the data in the "scope_metrics" field which have their own schema_url field. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The resource for the metrics in this message. + * If this field is not set then no resource info is known. + * + * Generated from protobuf field .opentelemetry.proto.resource.v1.Resource resource = 1; + * @return \Opentelemetry\Proto\Resource\V1\Resource|null + */ + public function getResource() + { + return $this->resource; + } + + public function hasResource() + { + return isset($this->resource); + } + + public function clearResource() + { + unset($this->resource); + } + + /** + * The resource for the metrics in this message. + * If this field is not set then no resource info is known. + * + * Generated from protobuf field .opentelemetry.proto.resource.v1.Resource resource = 1; + * @param \Opentelemetry\Proto\Resource\V1\Resource $var + * @return $this + */ + public function setResource($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Resource\V1\Resource::class); + $this->resource = $var; + + return $this; + } + + /** + * A list of metrics that originate from a resource. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.ScopeMetrics scope_metrics = 2; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getScopeMetrics() + { + return $this->scope_metrics; + } + + /** + * A list of metrics that originate from a resource. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.ScopeMetrics scope_metrics = 2; + * @param \Opentelemetry\Proto\Metrics\V1\ScopeMetrics[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setScopeMetrics($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\ScopeMetrics::class); + $this->scope_metrics = $arr; + + return $this; + } + + /** + * This schema_url applies to the data in the "resource" field. It does not apply + * to the data in the "scope_metrics" field which have their own schema_url field. + * + * Generated from protobuf field string schema_url = 3; + * @return string + */ + public function getSchemaUrl() + { + return $this->schema_url; + } + + /** + * This schema_url applies to the data in the "resource" field. It does not apply + * to the data in the "scope_metrics" field which have their own schema_url field. + * + * Generated from protobuf field string schema_url = 3; + * @param string $var + * @return $this + */ + public function setSchemaUrl($var) + { + GPBUtil::checkString($var, True); + $this->schema_url = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ScopeMetrics.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ScopeMetrics.php new file mode 100644 index 000000000..71f5cdb86 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/ScopeMetrics.php @@ -0,0 +1,153 @@ +opentelemetry.proto.metrics.v1.ScopeMetrics + */ +class ScopeMetrics extends \Google\Protobuf\Internal\Message +{ + /** + * The instrumentation scope information for the metrics in this message. + * Semantically when InstrumentationScope isn't set, it is equivalent with + * an empty instrumentation scope name (unknown). + * + * Generated from protobuf field .opentelemetry.proto.common.v1.InstrumentationScope scope = 1; + */ + protected $scope = null; + /** + * A list of metrics that originate from an instrumentation library. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Metric metrics = 2; + */ + private $metrics; + /** + * This schema_url applies to all metrics in the "metrics" field. + * + * Generated from protobuf field string schema_url = 3; + */ + protected $schema_url = ''; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\InstrumentationScope $scope + * The instrumentation scope information for the metrics in this message. + * Semantically when InstrumentationScope isn't set, it is equivalent with + * an empty instrumentation scope name (unknown). + * @type \Opentelemetry\Proto\Metrics\V1\Metric[]|\Google\Protobuf\Internal\RepeatedField $metrics + * A list of metrics that originate from an instrumentation library. + * @type string $schema_url + * This schema_url applies to all metrics in the "metrics" field. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The instrumentation scope information for the metrics in this message. + * Semantically when InstrumentationScope isn't set, it is equivalent with + * an empty instrumentation scope name (unknown). + * + * Generated from protobuf field .opentelemetry.proto.common.v1.InstrumentationScope scope = 1; + * @return \Opentelemetry\Proto\Common\V1\InstrumentationScope|null + */ + public function getScope() + { + return $this->scope; + } + + public function hasScope() + { + return isset($this->scope); + } + + public function clearScope() + { + unset($this->scope); + } + + /** + * The instrumentation scope information for the metrics in this message. + * Semantically when InstrumentationScope isn't set, it is equivalent with + * an empty instrumentation scope name (unknown). + * + * Generated from protobuf field .opentelemetry.proto.common.v1.InstrumentationScope scope = 1; + * @param \Opentelemetry\Proto\Common\V1\InstrumentationScope $var + * @return $this + */ + public function setScope($var) + { + GPBUtil::checkMessage($var, \Opentelemetry\Proto\Common\V1\InstrumentationScope::class); + $this->scope = $var; + + return $this; + } + + /** + * A list of metrics that originate from an instrumentation library. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Metric metrics = 2; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getMetrics() + { + return $this->metrics; + } + + /** + * A list of metrics that originate from an instrumentation library. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.Metric metrics = 2; + * @param \Opentelemetry\Proto\Metrics\V1\Metric[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setMetrics($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\Metric::class); + $this->metrics = $arr; + + return $this; + } + + /** + * This schema_url applies to all metrics in the "metrics" field. + * + * Generated from protobuf field string schema_url = 3; + * @return string + */ + public function getSchemaUrl() + { + return $this->schema_url; + } + + /** + * This schema_url applies to all metrics in the "metrics" field. + * + * Generated from protobuf field string schema_url = 3; + * @param string $var + * @return $this + */ + public function setSchemaUrl($var) + { + GPBUtil::checkString($var, True); + $this->schema_url = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Sum.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Sum.php new file mode 100644 index 000000000..0251ecd9f --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Sum.php @@ -0,0 +1,133 @@ +opentelemetry.proto.metrics.v1.Sum + */ +class Sum extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.NumberDataPoint data_points = 1; + */ + private $data_points; + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + */ + protected $aggregation_temporality = 0; + /** + * If "true" means that the sum is monotonic. + * + * Generated from protobuf field bool is_monotonic = 3; + */ + protected $is_monotonic = false; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\V1\NumberDataPoint[]|\Google\Protobuf\Internal\RepeatedField $data_points + * @type int $aggregation_temporality + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * @type bool $is_monotonic + * If "true" means that the sum is monotonic. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.NumberDataPoint data_points = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getDataPoints() + { + return $this->data_points; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.NumberDataPoint data_points = 1; + * @param \Opentelemetry\Proto\Metrics\V1\NumberDataPoint[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setDataPoints($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\NumberDataPoint::class); + $this->data_points = $arr; + + return $this; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @return int + */ + public function getAggregationTemporality() + { + return $this->aggregation_temporality; + } + + /** + * aggregation_temporality describes if the aggregator reports delta changes + * since last report time, or cumulative changes since a fixed start time. + * + * Generated from protobuf field .opentelemetry.proto.metrics.v1.AggregationTemporality aggregation_temporality = 2; + * @param int $var + * @return $this + */ + public function setAggregationTemporality($var) + { + GPBUtil::checkEnum($var, \Opentelemetry\Proto\Metrics\V1\AggregationTemporality::class); + $this->aggregation_temporality = $var; + + return $this; + } + + /** + * If "true" means that the sum is monotonic. + * + * Generated from protobuf field bool is_monotonic = 3; + * @return bool + */ + public function getIsMonotonic() + { + return $this->is_monotonic; + } + + /** + * If "true" means that the sum is monotonic. + * + * Generated from protobuf field bool is_monotonic = 3; + * @param bool $var + * @return $this + */ + public function setIsMonotonic($var) + { + GPBUtil::checkBool($var); + $this->is_monotonic = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Summary.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Summary.php new file mode 100644 index 000000000..adb5eceb9 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/Summary.php @@ -0,0 +1,65 @@ +opentelemetry.proto.metrics.v1.Summary + */ +class Summary extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.SummaryDataPoint data_points = 1; + */ + private $data_points; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Metrics\V1\SummaryDataPoint[]|\Google\Protobuf\Internal\RepeatedField $data_points + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.SummaryDataPoint data_points = 1; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getDataPoints() + { + return $this->data_points; + } + + /** + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.SummaryDataPoint data_points = 1; + * @param \Opentelemetry\Proto\Metrics\V1\SummaryDataPoint[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setDataPoints($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\SummaryDataPoint::class); + $this->data_points = $arr; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint.php new file mode 100644 index 000000000..30cf4ade4 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint.php @@ -0,0 +1,336 @@ +opentelemetry.proto.metrics.v1.SummaryDataPoint + */ +class SummaryDataPoint extends \Google\Protobuf\Internal\Message +{ + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 7; + */ + private $attributes; + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + */ + protected $start_time_unix_nano = 0; + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + */ + protected $time_unix_nano = 0; + /** + * count is the number of values in the population. Must be non-negative. + * + * Generated from protobuf field fixed64 count = 4; + */ + protected $count = 0; + /** + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#summary + * + * Generated from protobuf field double sum = 5; + */ + protected $sum = 0.0; + /** + * (Optional) list of values at different quantiles of the distribution calculated + * from the current snapshot. The quantiles must be strictly increasing. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.SummaryDataPoint.ValueAtQuantile quantile_values = 6; + */ + private $quantile_values; + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 8; + */ + protected $flags = 0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $attributes + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * @type int|string $start_time_unix_nano + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $time_unix_nano + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * @type int|string $count + * count is the number of values in the population. Must be non-negative. + * @type float $sum + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#summary + * @type \Opentelemetry\Proto\Metrics\V1\SummaryDataPoint\ValueAtQuantile[]|\Google\Protobuf\Internal\RepeatedField $quantile_values + * (Optional) list of values at different quantiles of the distribution calculated + * from the current snapshot. The quantiles must be strictly increasing. + * @type int $flags + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 7; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getAttributes() + { + return $this->attributes; + } + + /** + * The set of key/value pairs that uniquely identify the timeseries from + * where this point belongs. The list may be empty (may contain 0 elements). + * Attribute keys MUST be unique (it is not allowed to have more than one + * attribute with the same key). + * + * Generated from protobuf field repeated .opentelemetry.proto.common.v1.KeyValue attributes = 7; + * @param \Opentelemetry\Proto\Common\V1\KeyValue[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setAttributes($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Common\V1\KeyValue::class); + $this->attributes = $arr; + + return $this; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @return int|string + */ + public function getStartTimeUnixNano() + { + return $this->start_time_unix_nano; + } + + /** + * StartTimeUnixNano is optional but strongly encouraged, see the + * the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 start_time_unix_nano = 2; + * @param int|string $var + * @return $this + */ + public function setStartTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->start_time_unix_nano = $var; + + return $this; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @return int|string + */ + public function getTimeUnixNano() + { + return $this->time_unix_nano; + } + + /** + * TimeUnixNano is required, see the detailed comments above Metric. + * Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January + * 1970. + * + * Generated from protobuf field fixed64 time_unix_nano = 3; + * @param int|string $var + * @return $this + */ + public function setTimeUnixNano($var) + { + GPBUtil::checkUint64($var); + $this->time_unix_nano = $var; + + return $this; + } + + /** + * count is the number of values in the population. Must be non-negative. + * + * Generated from protobuf field fixed64 count = 4; + * @return int|string + */ + public function getCount() + { + return $this->count; + } + + /** + * count is the number of values in the population. Must be non-negative. + * + * Generated from protobuf field fixed64 count = 4; + * @param int|string $var + * @return $this + */ + public function setCount($var) + { + GPBUtil::checkUint64($var); + $this->count = $var; + + return $this; + } + + /** + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#summary + * + * Generated from protobuf field double sum = 5; + * @return float + */ + public function getSum() + { + return $this->sum; + } + + /** + * sum of the values in the population. If count is zero then this field + * must be zero. + * Note: Sum should only be filled out when measuring non-negative discrete + * events, and is assumed to be monotonic over the values of these events. + * Negative events *can* be recorded, but sum should not be filled out when + * doing so. This is specifically to enforce compatibility w/ OpenMetrics, + * see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#summary + * + * Generated from protobuf field double sum = 5; + * @param float $var + * @return $this + */ + public function setSum($var) + { + GPBUtil::checkDouble($var); + $this->sum = $var; + + return $this; + } + + /** + * (Optional) list of values at different quantiles of the distribution calculated + * from the current snapshot. The quantiles must be strictly increasing. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.SummaryDataPoint.ValueAtQuantile quantile_values = 6; + * @return \Google\Protobuf\Internal\RepeatedField + */ + public function getQuantileValues() + { + return $this->quantile_values; + } + + /** + * (Optional) list of values at different quantiles of the distribution calculated + * from the current snapshot. The quantiles must be strictly increasing. + * + * Generated from protobuf field repeated .opentelemetry.proto.metrics.v1.SummaryDataPoint.ValueAtQuantile quantile_values = 6; + * @param \Opentelemetry\Proto\Metrics\V1\SummaryDataPoint\ValueAtQuantile[]|\Google\Protobuf\Internal\RepeatedField $var + * @return $this + */ + public function setQuantileValues($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Opentelemetry\Proto\Metrics\V1\SummaryDataPoint\ValueAtQuantile::class); + $this->quantile_values = $arr; + + return $this; + } + + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 8; + * @return int + */ + public function getFlags() + { + return $this->flags; + } + + /** + * Flags that apply to this specific data point. See DataPointFlags + * for the available flags and their meaning. + * + * Generated from protobuf field uint32 flags = 8; + * @param int $var + * @return $this + */ + public function setFlags($var) + { + GPBUtil::checkUint32($var); + $this->flags = $var; + + return $this; + } + +} + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint/ValueAtQuantile.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint/ValueAtQuantile.php new file mode 100644 index 000000000..8200b6d26 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint/ValueAtQuantile.php @@ -0,0 +1,117 @@ +opentelemetry.proto.metrics.v1.SummaryDataPoint.ValueAtQuantile + */ +class ValueAtQuantile extends \Google\Protobuf\Internal\Message +{ + /** + * The quantile of a distribution. Must be in the interval + * [0.0, 1.0]. + * + * Generated from protobuf field double quantile = 1; + */ + protected $quantile = 0.0; + /** + * The value at the given quantile of a distribution. + * Quantile values must NOT be negative. + * + * Generated from protobuf field double value = 2; + */ + protected $value = 0.0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type float $quantile + * The quantile of a distribution. Must be in the interval + * [0.0, 1.0]. + * @type float $value + * The value at the given quantile of a distribution. + * Quantile values must NOT be negative. + * } + */ + public function __construct($data = NULL) { + \GPBMetadata\Opentelemetry\Proto\Metrics\V1\Metrics::initOnce(); + parent::__construct($data); + } + + /** + * The quantile of a distribution. Must be in the interval + * [0.0, 1.0]. + * + * Generated from protobuf field double quantile = 1; + * @return float + */ + public function getQuantile() + { + return $this->quantile; + } + + /** + * The quantile of a distribution. Must be in the interval + * [0.0, 1.0]. + * + * Generated from protobuf field double quantile = 1; + * @param float $var + * @return $this + */ + public function setQuantile($var) + { + GPBUtil::checkDouble($var); + $this->quantile = $var; + + return $this; + } + + /** + * The value at the given quantile of a distribution. + * Quantile values must NOT be negative. + * + * Generated from protobuf field double value = 2; + * @return float + */ + public function getValue() + { + return $this->value; + } + + /** + * The value at the given quantile of a distribution. + * Quantile values must NOT be negative. + * + * Generated from protobuf field double value = 2; + * @param float $var + * @return $this + */ + public function setValue($var) + { + GPBUtil::checkDouble($var); + $this->value = $var; + + return $this; + } + +} + +// Adding a class alias for backwards compatibility with the previous class name. +class_alias(ValueAtQuantile::class, \Opentelemetry\Proto\Metrics\V1\SummaryDataPoint_ValueAtQuantile::class); + diff --git a/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint_ValueAtQuantile.php b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint_ValueAtQuantile.php new file mode 100644 index 000000000..c1f41e749 --- /dev/null +++ b/vendor/open-telemetry/gen-otlp-protobuf/Opentelemetry/Proto/Metrics/V1/SummaryDataPoint_ValueAtQuantile.php @@ -0,0 +1,16 @@ +