diff --git a/modules/sync/googleapis/cloud-run/state.json b/modules/sync/googleapis/cloud-run/state.json index 1d642bc3..b0026e1d 100644 --- a/modules/sync/googleapis/cloud-run/state.json +++ b/modules/sync/googleapis/cloud-run/state.json @@ -2795,6 +2795,30 @@ { "name": "5f933a6c53e57f87e47e3725fceca08cf24b5b16", "digest": "ed45e833396f5005e7760a2f89fc16840d00cd9f3462d8ac1d33db00ba9c1193f1d13121a3b1404ea2837f644190046c6d4903bb251fe8f071f16f9cde6c1cca" + }, + { + "name": "a4d7050412f80d8846d2fcc3bc10fca0e7e7d49f", + "digest": "ed45e833396f5005e7760a2f89fc16840d00cd9f3462d8ac1d33db00ba9c1193f1d13121a3b1404ea2837f644190046c6d4903bb251fe8f071f16f9cde6c1cca" + }, + { + "name": "600f6707ff935d0162354178a6d09d04460d061a", + "digest": "ed45e833396f5005e7760a2f89fc16840d00cd9f3462d8ac1d33db00ba9c1193f1d13121a3b1404ea2837f644190046c6d4903bb251fe8f071f16f9cde6c1cca" + }, + { + "name": "a8598f68e1be76c31ac74f1cdcbe33fce642094d", + "digest": "ed45e833396f5005e7760a2f89fc16840d00cd9f3462d8ac1d33db00ba9c1193f1d13121a3b1404ea2837f644190046c6d4903bb251fe8f071f16f9cde6c1cca" + }, + { + "name": "45c8d8a7fb65aa944e843e975a51c307c1d026fb", + "digest": "ed45e833396f5005e7760a2f89fc16840d00cd9f3462d8ac1d33db00ba9c1193f1d13121a3b1404ea2837f644190046c6d4903bb251fe8f071f16f9cde6c1cca" + }, + { + "name": "bdf06d288033dbace2bebf1c526b7daf543552ed", + "digest": "ed45e833396f5005e7760a2f89fc16840d00cd9f3462d8ac1d33db00ba9c1193f1d13121a3b1404ea2837f644190046c6d4903bb251fe8f071f16f9cde6c1cca" + }, + { + "name": "38046d1d720f00070ea976c5aa6a3e3954c9b8c3", + "digest": "ed45e833396f5005e7760a2f89fc16840d00cd9f3462d8ac1d33db00ba9c1193f1d13121a3b1404ea2837f644190046c6d4903bb251fe8f071f16f9cde6c1cca" } ] } \ No newline at end of file diff --git a/modules/sync/googleapis/googleapis/state.json b/modules/sync/googleapis/googleapis/state.json index 6d866bbf..07503c5f 100644 --- a/modules/sync/googleapis/googleapis/state.json +++ b/modules/sync/googleapis/googleapis/state.json @@ -23707,6 +23707,30 @@ { "name": "5f933a6c53e57f87e47e3725fceca08cf24b5b16", "digest": "c62ecead9b13485a02893cd678a6c81e40879bf00ea509bbc6fd8f1b2cc33eccf6a85c259b08d1e0f052f693cbfc7dfda236e9665b1d6869b8e1132a794a61e2" + }, + { + "name": "a4d7050412f80d8846d2fcc3bc10fca0e7e7d49f", + "digest": "c62ecead9b13485a02893cd678a6c81e40879bf00ea509bbc6fd8f1b2cc33eccf6a85c259b08d1e0f052f693cbfc7dfda236e9665b1d6869b8e1132a794a61e2" + }, + { + "name": "600f6707ff935d0162354178a6d09d04460d061a", + "digest": "c62ecead9b13485a02893cd678a6c81e40879bf00ea509bbc6fd8f1b2cc33eccf6a85c259b08d1e0f052f693cbfc7dfda236e9665b1d6869b8e1132a794a61e2" + }, + { + "name": "a8598f68e1be76c31ac74f1cdcbe33fce642094d", + "digest": "c62ecead9b13485a02893cd678a6c81e40879bf00ea509bbc6fd8f1b2cc33eccf6a85c259b08d1e0f052f693cbfc7dfda236e9665b1d6869b8e1132a794a61e2" + }, + { + "name": "45c8d8a7fb65aa944e843e975a51c307c1d026fb", + "digest": "c62ecead9b13485a02893cd678a6c81e40879bf00ea509bbc6fd8f1b2cc33eccf6a85c259b08d1e0f052f693cbfc7dfda236e9665b1d6869b8e1132a794a61e2" + }, + { + "name": "bdf06d288033dbace2bebf1c526b7daf543552ed", + "digest": "c62ecead9b13485a02893cd678a6c81e40879bf00ea509bbc6fd8f1b2cc33eccf6a85c259b08d1e0f052f693cbfc7dfda236e9665b1d6869b8e1132a794a61e2" + }, + { + "name": "38046d1d720f00070ea976c5aa6a3e3954c9b8c3", + "digest": "c62ecead9b13485a02893cd678a6c81e40879bf00ea509bbc6fd8f1b2cc33eccf6a85c259b08d1e0f052f693cbfc7dfda236e9665b1d6869b8e1132a794a61e2" } ] } \ No newline at end of file diff --git a/modules/sync/opentelemetry/opentelemetry/cas/097bbf1f07eb73ba289ea12b5727283166d08239d702030db2dcce8b3ea1878c6db621b1d2a95e6354977c1c471cba1267f8fa0636c4b79d32c2d8d80512b0c9 b/modules/sync/opentelemetry/opentelemetry/cas/097bbf1f07eb73ba289ea12b5727283166d08239d702030db2dcce8b3ea1878c6db621b1d2a95e6354977c1c471cba1267f8fa0636c4b79d32c2d8d80512b0c9 new file mode 100644 index 00000000..3816dfa2 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/097bbf1f07eb73ba289ea12b5727283166d08239d702030db2dcce8b3ea1878c6db621b1d2a95e6354977c1c471cba1267f8fa0636c4b79d32c2d8d80512b0c9 @@ -0,0 +1,154 @@ +// Copyright 2019, OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package opentelemetry.proto.common.v1; + +option csharp_namespace = "OpenTelemetry.Proto.Common.V1"; +option java_multiple_files = true; +option java_package = "io.opentelemetry.proto.common.v1"; +option java_outer_classname = "CommonProto"; +option go_package = "go.opentelemetry.io/proto/otlp/common/v1"; + +// Represents any type of attribute value. AnyValue may contain a +// primitive value such as a string or integer or it may contain an arbitrary nested +// object containing arrays, key-value lists and primitives. +message AnyValue { + // The value is one of the listed fields. It is valid for all values to be unspecified + // in which case this AnyValue is considered to be "empty". + oneof value { + string string_value = 1; + bool bool_value = 2; + int64 int_value = 3; + double double_value = 4; + ArrayValue array_value = 5; + KeyValueList kvlist_value = 6; + bytes bytes_value = 7; + // Reference to the string value in ProfilesDictionary.string_table. + // + // Note: This is currently used exclusively in the Profiling signal. + // Implementers of OTLP receivers for signals other than Profiling should + // treat the presence of this value as a non-fatal issue. + // Log an error or warning indicating an unexpected field intended for the + // Profiling signal and process the data as if this value were absent or + // empty, ignoring its semantic content for the non-Profiling signal. + // + // Status: [Alpha] + int32 string_value_strindex = 8; + } +} + +// ArrayValue is a list of AnyValue messages. We need ArrayValue as a message +// since oneof in AnyValue does not allow repeated fields. +message ArrayValue { + // Array of values. The array may be empty (contain 0 elements). + repeated AnyValue values = 1; +} + +// KeyValueList is a list of KeyValue messages. We need KeyValueList as a message +// since `oneof` in AnyValue does not allow repeated fields. Everywhere else where we need +// a list of KeyValue messages (e.g. in Span) we use `repeated KeyValue` directly to +// avoid unnecessary extra wrapping (which slows down the protocol). The 2 approaches +// are semantically equivalent. +message KeyValueList { + // A collection of key/value pairs of key-value pairs. The list may be empty (may + // contain 0 elements). + // + // The keys MUST be unique (it is not allowed to have more than one + // value with the same key). + // The behavior of software that receives duplicated keys can be unpredictable. + repeated KeyValue values = 1; +} + +// Represents a key-value pair that is used to store Span attributes, Link +// attributes, etc. +message KeyValue { + // The key name of the pair. + // key_strindex MUST NOT be set if key is used. + string key = 1; + + // The value of the pair. + AnyValue value = 2; + + // Reference to the string key in ProfilesDictionary.string_table. + // key MUST NOT be set if key_strindex is used. + // + // Note: This is currently used exclusively in the Profiling signal. + // Implementers of OTLP receivers for signals other than Profiling should + // treat the presence of this key as a non-fatal issue. + // Log an error or warning indicating an unexpected field intended for the + // Profiling signal and process the data as if this value were absent or + // empty, ignoring its semantic content for the non-Profiling signal. + // + // Status: [Alpha] + int32 key_strindex = 3; +} + +// InstrumentationScope is a message representing the instrumentation scope information +// such as the fully qualified name and version. +message InstrumentationScope { + // A name denoting the Instrumentation scope. + // An empty instrumentation scope name means the name is unknown. + string name = 1; + + // Defines the version of the instrumentation scope. + // An empty instrumentation scope version means the version is unknown. + string version = 2; + + // Additional attributes that describe the scope. [Optional]. + // Attribute keys MUST be unique (it is not allowed to have more than one + // attribute with the same key). + // The behavior of software that receives duplicated keys can be unpredictable. + repeated KeyValue attributes = 3; + + // The number of attributes that were discarded. Attributes + // can be discarded because their keys are too long or because there are too many + // attributes. If this value is 0, then no attributes were dropped. + uint32 dropped_attributes_count = 4; +} + +// A reference to an Entity. +// Entity represents an object of interest associated with produced telemetry: e.g spans, metrics, profiles, or logs. +// +// Status: [Development] +message EntityRef { + // The Schema URL, if known. This is the identifier of the Schema that the entity data + // is recorded in. To learn more about Schema URL see + // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url + // + // This schema_url applies to the data in this message and to the Resource attributes + // referenced by id_keys and description_keys. + // TODO: discuss if we are happy with this somewhat complicated definition of what + // the schema_url applies to. + // + // This field obsoletes the schema_url field in ResourceMetrics/ResourceSpans/ResourceLogs. + string schema_url = 1; + + // Defines the type of the entity. MUST not change during the lifetime of the entity. + // For example: "service" or "host". This field is required and MUST not be empty + // for valid entities. + string type = 2; + + // Attribute Keys that identify the entity. + // MUST not change during the lifetime of the entity. The Id must contain at least one attribute. + // These keys MUST exist in the containing {message}.attributes. + repeated string id_keys = 3; + + // Descriptive (non-identifying) attribute keys of the entity. + // MAY change over the lifetime of the entity. MAY be empty. + // These attribute keys are not part of entity's identity. + // These keys MUST exist in the containing {message}.attributes. + repeated string description_keys = 4; +} \ No newline at end of file diff --git a/modules/sync/opentelemetry/opentelemetry/cas/0d1c9369ac685e0bdc1ffbe2744e2f07498168af5e6f82270701cb0a6f44f6775556c19b84b7bd7630512659c68c7bc7d4160d5a5a63fec9a823c372dca2d23c b/modules/sync/opentelemetry/opentelemetry/cas/0d1c9369ac685e0bdc1ffbe2744e2f07498168af5e6f82270701cb0a6f44f6775556c19b84b7bd7630512659c68c7bc7d4160d5a5a63fec9a823c372dca2d23c new file mode 100644 index 00000000..83f8f3d8 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/0d1c9369ac685e0bdc1ffbe2744e2f07498168af5e6f82270701cb0a6f44f6775556c19b84b7bd7630512659c68c7bc7d4160d5a5a63fec9a823c372dca2d23c @@ -0,0 +1,55 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package opentelemetry.proto.processcontext.v1development; + +import "opentelemetry/proto/common/v1/common.proto"; +import "opentelemetry/proto/resource/v1/resource.proto"; + +option csharp_namespace = "OpenTelemetry.Proto.ProcessContext.V1Development"; +option java_multiple_files = true; +option java_package = "io.opentelemetry.proto.processcontext.v1development"; +option java_outer_classname = "ProcessContextProto"; +option go_package = "go.opentelemetry.io/proto/otlp/processcontext/v1development"; + +// ProcessContext represents the payload for the process context sharing mechanism. +// +// This message is designed to be published by OpenTelemetry SDKs via a memory-mapped +// region, allowing external readers (such as the OpenTelemetry eBPF Profiler) to +// discover and read resource attributes from instrumented processes without requiring +// direct integration or process activity. It is not part of OTLP and is not +// exchanged via the OpenTelemetry Collector. +// +// See OTEP 4719 (https://github.com/open-telemetry/opentelemetry-specification/blob/main/oteps/profiles/4719-process-ctx.md) +// for details of this mechanism. +// +// Status: [Development] +message ProcessContext { + // The resource for this process. + // If this field is not set then no resource info is known. + opentelemetry.proto.resource.v1.Resource resource = 1; + + // Additional attributes to share with external readers that are not part of + // the standard Resource. [Optional] + // + // This field allows publishers to include supplementary key-value pairs that + // may be useful for external readers but are not part of the SDK's configured + // Resource. + // + // Consider adding any keys here to the profiles semantic conventions in + // https://opentelemetry.io/docs/specs/semconv/general/profiles/ + repeated opentelemetry.proto.common.v1.KeyValue attributes = 2; +} diff --git a/modules/sync/opentelemetry/opentelemetry/cas/16bccfa8028eb699701b6fb14599348de2a9a239bcb56c55a4ad11ec2a835f5e5848f8ac000c52890bad71a2722e369ee409a37ef4ef3e1dabc76884484579ec b/modules/sync/opentelemetry/opentelemetry/cas/16bccfa8028eb699701b6fb14599348de2a9a239bcb56c55a4ad11ec2a835f5e5848f8ac000c52890bad71a2722e369ee409a37ef4ef3e1dabc76884484579ec new file mode 100644 index 00000000..876f0187 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/16bccfa8028eb699701b6fb14599348de2a9a239bcb56c55a4ad11ec2a835f5e5848f8ac000c52890bad71a2722e369ee409a37ef4ef3e1dabc76884484579ec @@ -0,0 +1,537 @@ +// Copyright 2023, OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// This file includes work covered by the following copyright and permission notices: +// +// Copyright 2016 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package opentelemetry.proto.profiles.v1development; + +import "opentelemetry/proto/common/v1/common.proto"; +import "opentelemetry/proto/resource/v1/resource.proto"; + +option csharp_namespace = "OpenTelemetry.Proto.Profiles.V1Development"; +option java_multiple_files = true; +option java_package = "io.opentelemetry.proto.profiles.v1development"; +option java_outer_classname = "ProfilesProto"; +option go_package = "go.opentelemetry.io/proto/otlp/profiles/v1development"; + +// Relationships Diagram +// +// ┌──────────────────┐ LEGEND +// │ ProfilesData │ ─────┐ +// └──────────────────┘ │ ─────▶ embedded +// │ │ +// │ 1-n │ ─────▷ referenced by index +// ▼ ▼ +// ┌──────────────────┐ ┌────────────────────┐ +// │ ResourceProfiles │ │ ProfilesDictionary │ +// └──────────────────┘ └────────────────────┘ +// │ +// │ 1-n +// ▼ +// ┌──────────────────┐ +// │ ScopeProfiles │ +// └──────────────────┘ +// │ +// │ 1-n +// ▼ +// ┌──────────────────┐ +// │ Profile │ +// └──────────────────┘ +// │ n-1 +// │ 1-n ┌───────────────────────────────────────┐ +// ▼ │ ▽ +// ┌──────────────────┐ n-n ┌─────────────────┐ ┌──────────┐ +// │ Sample │ ──────▷ │ KeyValueAndUnit │ │ Link │ +// └──────────────────┘ └─────────────────┘ └──────────┘ +// │ △ △ +// │ n-1 │ │ n-n +// ▽ │ │ +// ┌──────────────────┐ │ │ +// │ Stack │ │ │ +// └──────────────────┘ │ │ +// │ n-n │ │ +// │ n-n ┌────────────────┘ │ +// ▽ │ │ +// ┌──────────────────┐ n-1 ┌─────────────┐ +// │ Location │ ──────▷ │ Mapping │ +// └──────────────────┘ └─────────────┘ +// │ +// │ 1-n +// ▼ +// ┌──────────────────┐ +// │ Line │ +// └──────────────────┘ +// │ +// │ n-1 +// ▽ +// ┌──────────────────┐ +// │ Function │ +// └──────────────────┘ +// + +// ProfilesDictionary contains all the dictionary tables that are shared +// across the entire ProfilesData message. +// +// The following applies to all fields in this message: +// +// - A dictionary is an array of dictionary items. Users of the dictionary +// compactly reference the items using the index within the array. +// +// - The element at index 0 MUST be the zero value for the dictionary's element +// type (e.g. `""` for `string_table`, `Location{}` for `location_table`). This +// allows for _index fields pointing into the dictionary to use a 0 pointer +// value to indicate 'null' / 'not set'. Unless otherwise defined, a 'zero +// value' message value is one with all default field values, so as to +// minimize wire encoded size. +// +// - There SHOULD NOT be duplicate items in a dictionary. The identity of a +// dictionary item is based on its value, recursively as needed. If a particular +// implementation does emit duplicate items, it MUST NOT attempt to give them +// meaning based on the index or order. A profile processor MAY remove +// duplicates and this MUST NOT have any observable effects for consumers. +// +// - There SHOULD NOT be orphaned (unreferenced) items in a dictionary. A +// profile processor MAY remove ("garbage-collect") orphaned items and this +// MUST NOT have any observable effects for consumers. +// +// Status: [Alpha] +message ProfilesDictionary { + // Mappings from address ranges to the image/binary/library mapped + // into that address range referenced by locations via Location.mapping_index. + // + // mapping_table[0] MUST be the zero value (Mapping{}) and present. + repeated Mapping mapping_table = 1; + + // Locations referenced by samples via Stack.location_indices. + // + // location_table[0] MUST be the zero value (Location{}) and present. + repeated Location location_table = 2; + + // Functions referenced by locations via Line.function_index. + // + // function_table[0] MUST be the zero value (Function{}) and present. + repeated Function function_table = 3; + + // Links referenced by samples via Sample.link_index. + // + // link_table[0] MUST be the zero value (Link{}) and present. + // Note that whilst Link{trace_id=array[0], span_id=array[0]} and + // Link{trace_id=array[16], span_id=array[8]} filled with zero-value bytes + // are both appropriate zero/invalid values per the trace.proto:Span definition, + // the latter SHOULD be used for link_table[0] for better compatibility with codecs + // strictly expecting 16/8 byte array lengths. + repeated Link link_table = 4; + + // A common table for strings referenced by various messages. + // + // string_table[0] MUST be "" and present. + repeated string string_table = 5; + + // A common table for attributes referenced by the Profile, Sample, Mapping + // and Location messages, through their attribute_indices field. Each entry is + // a key/value pair with an optional unit in UCUM format. Since this is a + // dictionary table, multiple entries with the same key MAY be present, + // unlike direct attribute tables like Resource.attributes. + // However, the referencing attribute_indices fields MUST maintain the key + // uniqueness requirement. + // + // It's recommended to use attributes for variables with bounded cardinality, + // such as categorical variables + // (https://en.wikipedia.org/wiki/Categorical_variable). Using an attribute of + // a floating point type (e.g., CPU time) in a sample can quickly make every + // attribute value unique, defeating the purpose of the dictionary and + // impractically increasing the profile size. + // + // Examples of attributes: + // "/http/user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36" + // "abc.com/myattribute": true + // "allocation_size": 128 bytes + // + // attribute_table[0] MUST be the zero value (KeyValueAndUnit{}) and present. + repeated KeyValueAndUnit attribute_table = 6; + + // Stacks referenced by samples via Sample.stack_index. + // + // stack_table[0] MUST be the zero value (Stack{}) and present. + repeated Stack stack_table = 7; +} + +// ProfilesData represents the profiles data that can be stored in persistent storage, +// OR can be embedded by other protocols that transfer OTLP profiles data but do not +// implement the OTLP protocol. +// +// The main difference between this message and collector protocol is that +// in this message there will not be any "control" or "metadata" specific to +// OTLP protocol. +// +// When new fields are added into this message, the OTLP request MUST be updated +// as well. +// +// Status: [Alpha] +message ProfilesData { + // An array of ResourceProfiles. + // For data coming from an SDK profiler, this array will typically contain one + // element. Host-level profilers will usually create one ResourceProfile per + // container, as well as one additional ResourceProfile grouping all samples + // from non-containerized processes. + // Other resource groupings are possible as well and clarified via + // Resource.attributes and semantic conventions. + // Tools that visualize profiles SHOULD prefer displaying + // resources_profiles[0].scope_profiles[0].profiles[0] by default. + repeated ResourceProfiles resource_profiles = 1; + + // A single instance of ProfilesDictionary shared across the entire message. + ProfilesDictionary dictionary = 2; +} + + +// A collection of ScopeProfiles from a Resource. +// +// Status: [Alpha] +message ResourceProfiles { + reserved 1000; + + // The resource for the profiles in this message. + // If this field is not set then no resource info is known. + opentelemetry.proto.resource.v1.Resource resource = 1; + + // A list of ScopeProfiles that originate from this resource. + repeated ScopeProfiles scope_profiles = 2; + + // The Schema URL, if known. This is the identifier of the Schema that the resource data + // is recorded in. Notably, the last part of the URL path is the version number of the + // schema: http[s]://server[:port]/path/. To learn more about Schema URL see + // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url + // This schema_url applies to the data in the "resource" field. It does not apply + // to the data in the "scope_profiles" field, which has its own schema_url field. + string schema_url = 3; +} + +// A collection of Profiles produced by an InstrumentationScope. +// +// Status: [Alpha] +message ScopeProfiles { + // The instrumentation scope information for the profiles in this message. + // Semantically when InstrumentationScope isn't set, it is equivalent with + // an empty instrumentation scope name (unknown). + opentelemetry.proto.common.v1.InstrumentationScope scope = 1; + + // A list of Profiles that originate from this instrumentation scope. + repeated Profile profiles = 2; + + // The Schema URL, if known. This is the identifier of the Schema that the profile data + // is recorded in. Notably, the last part of the URL path is the version number of the + // schema: http[s]://server[:port]/path/. To learn more about Schema URL see + // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url + // This schema_url applies to the data in the "scope" field and all profiles in the + // "profiles" field. + string schema_url = 3; +} + +// Profile is a common stacktrace profile format. +// +// Measurements represented with this format should follow the +// following conventions: +// +// - Consumers SHOULD treat unset optional fields as if they had been +// set with their default value. We discourage using the protobuf +// presence semantics, even if available in the protobuf generated API. +// +// - When possible, measurements SHOULD be stored in "unsampled" form +// that is most useful to humans. There should be enough +// information present to determine the original sampled values. +// +// - The profile is represented as a set of samples, where each sample +// references a stack trace which is a list of locations, each belonging +// to a mapping. +// +// - There is a N->1 relationship from Stack.location_indices entries to +// locations. For every Stack.location_indices entry there MUST be a +// unique Location with that index. +// +// - There is an optional N->1 relationship from locations to +// mappings. For every nonzero Location.mapping_id there MUST be a +// unique Mapping with that index. + +// Represents a complete profile, including sample types, samples, mappings to +// binaries, stacks, locations, functions, string table, and additional +// metadata. It modifies and annotates pprof Profile with OpenTelemetry +// specific fields. +// +// Status: [Alpha] +message Profile { + // The type and unit of all Sample.values in this profile. + // For a cpu or off-cpu profile this might be: + // ["cpu","nanoseconds"] or ["off_cpu","nanoseconds"] + // For a heap profile, this might be: + // ["allocated_objects","count"] or ["allocated_space","bytes"], + ValueType sample_type = 1; + // The set of samples recorded in this profile. + repeated Sample samples = 2; + + // The following fields 3-12 are informational, do not affect + // interpretation of results. + + // Time of collection (UTC) as nanoseconds since the UNIX epoch. + fixed64 time_unix_nano = 3; + // Duration of the profile in nanoseconds. For instant profiles like + // live heap snapshot, the duration can be zero but it may be preferable + // to set time_unix_nano to the process start time and duration_nano to + // the relative time when the profile was gathered so that Sample.timestamps_unix_nano + // values fall within the profile time range. + uint64 duration_nano = 4; + // The type and the unit of the events between sampled occurrences for + // periodic sampling profiles. It can be the same as sample_type or it can be + // different depending on the case, for example: + // - sample_type=(cpu, milliseconds), period_type=(cpu, milliseconds), + // period=10 signals that we sample the program every 10 milliseconds and + // capture samples that each represent that sampling distance. + // - sample_type=(off_cpu, nanoseconds), period_type=(context_switch, count), + // period=1000 describes a profile where sampling is done every so often in + // terms of context switches, but the recorded metric is the time spent by + // the thread off CPU. + // - sample_type=(inuse_space, bytes), period_type=(allocated_bytes, bytes), + // period=262144 might represent a heap profile where the recorded sample + // metric is the size of the live heap while the periodic sampling is done + // using the number of cumulatively allocated bytes. + ValueType period_type = 5; + // The distance between sampled occurrences for periodic sampling profiles. + // The value is of the period_type type and unit. + int64 period = 6; + + // A globally unique identifier for a profile. The ID is a 16-byte array. An ID with + // all zeroes is considered invalid. It MAY be used for deduplication and signal + // correlation purposes. It is acceptable to treat two profiles with different values + // in this field as not equal, even if they represented the same object at an earlier + // time. + // This field is optional; an ID may be assigned to an ID-less profile in a later step. + bytes profile_id = 7; + + // The number of attributes that were discarded. Attributes + // can be discarded because their keys are too long or because there are too many + // attributes. If this value is 0, then no attributes were dropped. + uint32 dropped_attributes_count = 8; + + // The original payload format. See also original_payload. It MUST be set + // together with original_payload or both left unset [optional]. + // + // The allowed values for the format string are defined by the OpenTelemetry + // specification. Some examples are "jfr", "pprof", "linux_perf". + // + // The original_payload MAY be used when converting from a source format (e.g. JFR) + // that carries information which cannot be losslessly represented in the + // Profiles format. Including the original data allows receivers to store or + // reexport the data without loss. Because the original payload can be large, + // its inclusion is optional. + string original_payload_format = 9; + // The original payload bytes. See also original_payload_format. It MUST be set + // together with original_payload_format or both left unset [optional]. + bytes original_payload = 10; + + // References to attributes in attribute_table. [optional] + repeated int32 attribute_indices = 11; +} + +// A pointer from a profile Sample to a trace Span. +// Connects a profile sample to a trace span, identified by unique trace and span IDs. +// +// Status: [Alpha] +message Link { + // A unique identifier of the trace that this linked span is part of. The ID is a + // 16-byte array. + bytes trace_id = 1; + + // A unique identifier for the linked span. The ID is an 8-byte array. + bytes span_id = 2; +} + +// ValueType describes the type and units of a value. +// +// Status: [Alpha] +message ValueType { + // Index into ProfilesDictionary.string_table. + int32 type_strindex = 1; + + // Index into ProfilesDictionary.string_table. + int32 unit_strindex = 2; +} + +// Each Sample records values encountered in some program context. The program +// context is typically a stack trace, perhaps augmented with auxiliary +// information like the thread-id, some indicator of a higher level request +// being handled etc. +// +// A Sample MUST have have at least one entry in values or timestamps_unix_nano. +// If both fields are populated, they MUST contain the same number of elements, +// and the elements at the same index MUST refer to the same event. +// +// For the purposes of efficiently representing aggregated data observations, a Sample is regarded +// as having a shared identity and an associated collection of per-observation data points. +// A Sample's identity (i.e. primary key) is the tuple of {stack_index, set_of(attribute_indices), link_index}. +// Samples having the same identity SHOULD be combined by appending timestamps and values to the data arrays. +// +// Examples of different ways ('shapes') of representing a sample with the total value of 10: +// +// Timestamps only (consumers must assume the value is 1 for each timestamp): +// values: [] +// timestamps_unix_nano: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +// +// Single aggregated value without timestamps (one element representing the total): +// values: [10] +// timestamps_unix_nano: [] +// +// Per-timestamp value (each point in time records a specific value): +// values: [2, 2, 3, 3] +// timestamps_unix_nano: [1, 2, 3, 4] +// +// All Samples for a Profile SHOULD have the same shape, i.e. all data observation series should consistently +// adopt the same data recording style. +// +// Status: [Alpha] +message Sample { + // Reference to stack in ProfilesDictionary.stack_table. + int32 stack_index = 1; + // References to attributes in ProfilesDictionary.attribute_table. [optional] + repeated int32 attribute_indices = 2; + // Reference to link in ProfilesDictionary.link_table. [optional] + // 0 means no link exists. + int32 link_index = 3; + + // The following fields may contain per-observation data and do not form part of the Sample's identity. + + // Measured values. The type and unit of each value is defined by Profile.sample_type. + repeated int64 values = 4; + // Timestamps (UTC) as nanoseconds since the UNIX epoch. The timestamps SHOULD fall within the + // [Profile.time_unix_nano, Profile.time_unix_nano + Profile.duration_nano) interval. + repeated fixed64 timestamps_unix_nano = 5; +} + +// Describes the mapping of a binary in memory, including its address range, +// file offset, and metadata like build ID +// +// Status: [Alpha] +message Mapping { + // Address at which the binary (or DLL) is loaded into memory. + uint64 memory_start = 1; + // The limit of the address range occupied by this mapping. + uint64 memory_limit = 2; + // Offset in the binary that corresponds to the first mapped address. + uint64 file_offset = 3; + // The object this entry is loaded from. This can be a filename on + // disk for the main binary and shared libraries, or a virtual + // abstraction like "[vdso]". + int32 filename_strindex = 4; // Index into ProfilesDictionary.string_table. + // References to attributes in ProfilesDictionary.attribute_table. [optional] + repeated int32 attribute_indices = 5; +} + +// A Stack represents a stack trace as a list of locations (leaf first). +// For example, the stack trace resulting from the call stack +// main -> foo -> bar would be encoded into the location_indices list +// [2, 1, 0] which references the locations in location_table as: +// [Location{"main"}, Location{"foo"}, Location{"bar"}]. +// +// Status: [Alpha] +message Stack { + // References to locations in ProfilesDictionary.location_table. + // The first location is the leaf frame. + repeated int32 location_indices = 1; +} + +// Contains function and line table debug information for a single frame. +// +// Status: [Alpha] +message Location { + // Reference to mapping in ProfilesDictionary.mapping_table. + // 0 means unknown or not applicable. + int32 mapping_index = 1; + // The instruction address for this location, if available. It + // SHOULD be within [Mapping.memory_start, Mapping.memory_limit] + // for the corresponding mapping. A non-leaf address may be in the + // middle of a call instruction. It is up to display tools to find + // the beginning of the instruction if necessary. + uint64 address = 2; + // Multiple lines indicate this location has inlined functions, + // where the last entry represents the caller into which the + // preceding entries were inlined. + // + // E.g., if memcpy() is inlined into printf: + // lines[0].function_name == "memcpy" + // lines[1].function_name == "printf" + repeated Line lines = 3; + // References to attributes in ProfilesDictionary.attribute_table. [optional] + repeated int32 attribute_indices = 4; +} + +// Details a specific line in a source code, linked to a function. +// +// Status: [Alpha] +message Line { + // Reference to function in ProfilesDictionary.function_table. + int32 function_index = 1; + // Line number in source code. 1-based, 0 means unset. + int64 line = 2; + // Column number in source code. 1-based, 0 means unset. + int64 column = 3; +} + +// Describes a function, including its human-readable name, system name, +// source file, and starting line number in the source. At least one of +// {name_strindex, system_name_strindex, filename_strindex} MUST be present. +// +// Status: [Alpha] +message Function { + // The function name. Empty string if not available. + int32 name_strindex = 1; + // Function name, as identified by the system. For instance, + // it can be a C++ mangled name. Empty string if not available. + int32 system_name_strindex = 2; + // Source file containing the function. Empty string if not available. + int32 filename_strindex = 3; + // Line number in source file. 1-based, 0 means unset. + int64 start_line = 4; +} + +// A custom 'dictionary native' style of encoding attributes which is more convenient +// for profiles than opentelemetry.proto.common.v1.KeyValue +// Specifically, uses the ProfilesDictionary.string_table for keys +// and allows optional unit information. +// +// Status: [Alpha] +message KeyValueAndUnit { + // The index into the string table for the attribute's key. + int32 key_strindex = 1; + // The value of the attribute. + opentelemetry.proto.common.v1.AnyValue value = 2; + // The index into the string table for the attribute's unit. + // zero indicates implicit (by semconv) or non-defined unit. + // If present, the unit string SHOULD be in UCUM format. + int32 unit_strindex = 3; +} diff --git a/modules/sync/opentelemetry/opentelemetry/cas/2c4433c14b51cf40358b2c22ed9f6335ca4e76831b0d12dd887e6cc3c2c87afd652d2159ff8b1c29512c1c2ada9aa67c066d7d298823b815453f6609b2f0513d b/modules/sync/opentelemetry/opentelemetry/cas/2c4433c14b51cf40358b2c22ed9f6335ca4e76831b0d12dd887e6cc3c2c87afd652d2159ff8b1c29512c1c2ada9aa67c066d7d298823b815453f6609b2f0513d new file mode 100644 index 00000000..6fc3f7ed --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/2c4433c14b51cf40358b2c22ed9f6335ca4e76831b0d12dd887e6cc3c2c87afd652d2159ff8b1c29512c1c2ada9aa67c066d7d298823b815453f6609b2f0513d @@ -0,0 +1,14 @@ +**This is a third-party repository managed by Buf.** + +Updates to the [source repository](https://github.com/open-telemetry/opentelemetry-proto) are +automatically synced on a periodic basis, and each BSR commit is tagged with corresponding Git +semver releases. + +To depend on a specific version, you can use it as your reference in your dependencies: + +``` +deps: + - {{bsrhost}}/opentelemetry/opentelemetry: +``` + +For more information, see the [documentation](https://buf.build/docs/bsr/overview). diff --git a/modules/sync/opentelemetry/opentelemetry/cas/57b8c0a8cdeaf2d041aae974946f4bf0c0da3a92ef7556d9547985690a793e070527a9ace5932153cdf4f4ba870207eba72e9702cc1efb45bf885ab9bffc758b b/modules/sync/opentelemetry/opentelemetry/cas/57b8c0a8cdeaf2d041aae974946f4bf0c0da3a92ef7556d9547985690a793e070527a9ace5932153cdf4f4ba870207eba72e9702cc1efb45bf885ab9bffc758b new file mode 100644 index 00000000..16873867 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/57b8c0a8cdeaf2d041aae974946f4bf0c0da3a92ef7556d9547985690a793e070527a9ace5932153cdf4f4ba870207eba72e9702cc1efb45bf885ab9bffc758b @@ -0,0 +1,735 @@ +// Copyright 2019, OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package opentelemetry.proto.metrics.v1; + +import "opentelemetry/proto/common/v1/common.proto"; +import "opentelemetry/proto/resource/v1/resource.proto"; + +option csharp_namespace = "OpenTelemetry.Proto.Metrics.V1"; +option java_multiple_files = true; +option java_package = "io.opentelemetry.proto.metrics.v1"; +option java_outer_classname = "MetricsProto"; +option go_package = "go.opentelemetry.io/proto/otlp/metrics/v1"; + +// MetricsData represents the metrics data that can be stored in a persistent +// storage, OR can be embedded by other protocols that transfer OTLP metrics +// data but do not implement the OTLP protocol. +// +// MetricsData +// └─── ResourceMetrics +// ├── Resource +// ├── SchemaURL +// └── ScopeMetrics +// ├── Scope +// ├── SchemaURL +// └── Metric +// ├── Name +// ├── Description +// ├── Unit +// └── data +// ├── Gauge +// ├── Sum +// ├── Histogram +// ├── ExponentialHistogram +// └── Summary +// +// The main difference between this message and collector protocol is that +// in this message there will not be any "control" or "metadata" specific to +// OTLP protocol. +// +// When new fields are added into this message, the OTLP request MUST be updated +// as well. +message MetricsData { + // 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. + repeated ResourceMetrics resource_metrics = 1; +} + +// A collection of ScopeMetrics from a Resource. +message ResourceMetrics { + reserved 1000; + + // The resource for the metrics in this message. + // If this field is not set then no resource info is known. + opentelemetry.proto.resource.v1.Resource resource = 1; + + // A list of metrics that originate from a resource. + repeated ScopeMetrics scope_metrics = 2; + + // The Schema URL, if known. This is the identifier of the Schema that the resource data + // is recorded in. Notably, the last part of the URL path is the version number of the + // schema: http[s]://server[:port]/path/. To learn more about Schema URL see + // https://opentelemetry.io/docs/specs/otel/schemas/#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. + string schema_url = 3; +} + +// A collection of Metrics produced by an Scope. +message ScopeMetrics { + // 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). + opentelemetry.proto.common.v1.InstrumentationScope scope = 1; + + // A list of metrics that originate from an instrumentation library. + repeated Metric metrics = 2; + + // The Schema URL, if known. This is the identifier of the Schema that the metric data + // is recorded in. Notably, the last part of the URL path is the version number of the + // schema: http[s]://server[:port]/path/. To learn more about Schema URL see + // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url + // This schema_url applies to the data in the "scope" field and all metrics in the + // "metrics" field. + string schema_url = 3; +} + +// Defines a Metric which has one or more timeseries. The following is a +// brief summary of the Metric data model. For more details, see: +// +// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/data-model.md +// +// The data model and relation between entities is shown in the +// diagram below. Here, "DataPoint" is the term used to refer to any +// one of the specific data point value types, and "points" is the term used +// to refer to any one of the lists of points contained in the Metric. +// +// - Metric is composed of a metadata and data. +// - Metadata part contains a name, description, unit. +// - Data is one of the possible types (Sum, Gauge, Histogram, Summary). +// - DataPoint contains timestamps, attributes, and one of the possible value type +// fields. +// +// Metric +// +------------+ +// |name | +// |description | +// |unit | +------------------------------------+ +// |data |---> |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. +message Metric { + reserved 4, 6, 8; + + // The name of the metric. + string name = 1; + + // A description of the metric, which can be used in documentation. + string description = 2; + + // The unit in which the metric value is reported. Follows the format + // described by https://ucum.org/ucum and https://units-of-measurement.org/ + string unit = 3; + + // Data determines the aggregation type (if any) of the metric, what is the + // reported value type for the data points, as well as the relatationship to + // the time interval over which they are reported. + oneof data { + Gauge gauge = 5; + Sum sum = 7; + Histogram histogram = 9; + ExponentialHistogram exponential_histogram = 10; + Summary summary = 11; + } + + // Additional metadata attributes that describe the metric. [Optional]. + // Attributes are non-identifying. + // Consumers SHOULD NOT need to be aware of these attributes. + // These attributes MAY be used to encode information allowing + // for lossless roundtrip translation to / from another data model. + // Attribute keys MUST be unique (it is not allowed to have more than one + // attribute with the same key). + // The behavior of software that receives duplicated keys can be unpredictable. + repeated opentelemetry.proto.common.v1.KeyValue metadata = 12; +} + +// Gauge represents the type of a scalar metric that always exports the +// "current value" for every data point. It should be used for an "unknown" +// aggregation. +// +// A Gauge does not support different aggregation temporalities. Given the +// aggregation is unknown, points cannot be combined using the same +// aggregation, regardless of aggregation temporalities. Therefore, +// AggregationTemporality is not included. Consequently, this also means +// "StartTimeUnixNano" is ignored for all data points. +message Gauge { + // The time series data points. + // Note: Multiple time series may be included (same timestamp, different attributes). + repeated NumberDataPoint data_points = 1; +} + +// Sum represents the type of a scalar metric that is calculated as a sum of all +// reported measurements over a time interval. +message Sum { + // The time series data points. + // Note: Multiple time series may be included (same timestamp, different attributes). + repeated NumberDataPoint data_points = 1; + + // aggregation_temporality describes if the aggregator reports delta changes + // since last report time, or cumulative changes since a fixed start time. + AggregationTemporality aggregation_temporality = 2; + + // Represents whether the sum is monotonic. + bool is_monotonic = 3; +} + +// Histogram represents the type of a metric that is calculated by aggregating +// as a Histogram of all reported measurements over a time interval. +message Histogram { + // The time series data points. + // Note: Multiple time series may be included (same timestamp, different attributes). + repeated HistogramDataPoint data_points = 1; + + // aggregation_temporality describes if the aggregator reports delta changes + // since last report time, or cumulative changes since a fixed start time. + AggregationTemporality aggregation_temporality = 2; +} + +// ExponentialHistogram represents the type of a metric that is calculated by aggregating +// as a ExponentialHistogram of all reported double measurements over a time interval. +message ExponentialHistogram { + // The time series data points. + // Note: Multiple time series may be included (same timestamp, different attributes). + repeated ExponentialHistogramDataPoint data_points = 1; + + // aggregation_temporality describes if the aggregator reports delta changes + // since last report time, or cumulative changes since a fixed start time. + AggregationTemporality aggregation_temporality = 2; +} + +// Summary metric data are used to convey quantile summaries, +// a Prometheus (see: https://prometheus.io/docs/concepts/metric_types/#summary) +// and OpenMetrics (see: https://github.com/prometheus/OpenMetrics/blob/4dbf6075567ab43296eed941037c12951faafb92/protos/prometheus.proto#L45) +// data type. These data points cannot always be merged in a meaningful way. +// While they can be useful in some applications, histogram data points are +// recommended for new applications. +// Summary metrics do not have an aggregation temporality field. This is +// because the count and sum fields of a SummaryDataPoint are assumed to be +// cumulative values. +message Summary { + // The time series data points. + // Note: Multiple time series may be included (same timestamp, different attributes). + repeated SummaryDataPoint data_points = 1; +} + +// AggregationTemporality defines how a metric aggregator reports aggregated +// values. It describes how those values relate to the time interval over +// which they are aggregated. +enum AggregationTemporality { + // UNSPECIFIED is the default AggregationTemporality, it MUST not be used. + 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. + 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). + AGGREGATION_TEMPORALITY_CUMULATIVE = 2; +} + +// DataPointFlags is defined as a protobuf 'uint32' type and is to be used as a +// bit-field representing 32 distinct boolean flags. Each flag defined in this +// enum is a bit-mask. To test the presence of a single flag in the flags of +// a data point, for example, use an expression like: +// +// (point.flags & DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK) == DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK +// +enum DataPointFlags { + // The zero value for the enum. Should not be used for comparisons. + // Instead use bitwise "and" with the appropriate mask as shown above. + 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". + DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK = 1; + + // Bits 2-31 are reserved for future use. +} + +// NumberDataPoint is a single data point in a timeseries that describes the +// time-varying scalar value of a metric. +message NumberDataPoint { + reserved 1; + + // 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). + // The behavior of software that receives duplicated keys can be unpredictable. + repeated opentelemetry.proto.common.v1.KeyValue attributes = 7; + + // 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. + fixed64 start_time_unix_nano = 2; + + // 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. + fixed64 time_unix_nano = 3; + + // The value itself. A point is considered invalid when one of the recognized + // value fields is not present inside this oneof. + oneof value { + double as_double = 4; + sfixed64 as_int = 6; + } + + // (Optional) List of exemplars collected from + // measurements that were used to form the data point + repeated Exemplar exemplars = 5; + + // Flags that apply to this specific data point. See DataPointFlags + // for the available flags and their meaning. + uint32 flags = 8; +} + +// HistogramDataPoint is a single data point in a timeseries that describes the +// time-varying values of a Histogram. A Histogram contains summary statistics +// for a population of values, it may optionally contain the distribution of +// those values across a set of buckets. +// +// If the histogram contains the distribution of values, then both +// "explicit_bounds" and "bucket counts" fields must be defined. +// If the histogram does not contain the distribution of values, then both +// "explicit_bounds" and "bucket_counts" must be omitted and only "count" and +// "sum" are known. +message HistogramDataPoint { + reserved 1; + + // 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). + // The behavior of software that receives duplicated keys can be unpredictable. + repeated opentelemetry.proto.common.v1.KeyValue attributes = 9; + + // 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. + fixed64 start_time_unix_nano = 2; + + // 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. + fixed64 time_unix_nano = 3; + + // 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. + fixed64 count = 4; + + // 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/prometheus/OpenMetrics/blob/v1.0.0/specification/OpenMetrics.md#histogram + optional double sum = 5; + + // 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. The exception to this rule + // is when the length of bucket_counts is 0, then the length of explicit_bounds + // must also be 0. + repeated fixed64 bucket_counts = 6; + + // 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. + // + // If bucket_counts length is 0 then explicit_bounds length must also be 0, + // otherwise the data point is invalid. + repeated double explicit_bounds = 7; + + // (Optional) List of exemplars collected from + // measurements that were used to form the data point + repeated Exemplar exemplars = 8; + + // Flags that apply to this specific data point. See DataPointFlags + // for the available flags and their meaning. + uint32 flags = 10; + + // min is the minimum value over (start_time, end_time]. + optional double min = 11; + + // max is the maximum value over (start_time, end_time]. + optional double max = 12; +} + +// ExponentialHistogramDataPoint is a single data point in a timeseries that describes the +// time-varying values of a ExponentialHistogram of double values. A ExponentialHistogram contains +// summary statistics for a population of values, it may optionally contain the +// distribution of those values across a set of buckets. +// +message ExponentialHistogramDataPoint { + // 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). + // The behavior of software that receives duplicated keys can be unpredictable. + repeated opentelemetry.proto.common.v1.KeyValue attributes = 1; + + // 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. + fixed64 start_time_unix_nano = 2; + + // 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. + fixed64 time_unix_nano = 3; + + // 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. + fixed64 count = 4; + + // The 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/prometheus/OpenMetrics/blob/v1.0.0/specification/OpenMetrics.md#histogram + optional double sum = 5; + + // 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. + sint32 scale = 6; + + // 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). + fixed64 zero_count = 7; + + // positive carries the positive range of exponential bucket counts. + Buckets positive = 8; + + // negative carries the negative range of exponential bucket counts. + Buckets negative = 9; + + // Buckets are a set of bucket counts, encoded in a contiguous array + // of counts. + message Buckets { + // The bucket index of the first entry in the bucket_counts array. + // + // Note: This uses a varint encoding as a simple form of compression. + sint32 offset = 1; + + // 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. + repeated uint64 bucket_counts = 2; + } + + // Flags that apply to this specific data point. See DataPointFlags + // for the available flags and their meaning. + uint32 flags = 10; + + // (Optional) List of exemplars collected from + // measurements that were used to form the data point + repeated Exemplar exemplars = 11; + + // The minimum value over (start_time, end_time]. + optional double min = 12; + + // The maximum value over (start_time, end_time]. + optional double max = 13; + + // 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. + double zero_threshold = 14; +} + +// SummaryDataPoint is a single data point in a timeseries that describes the +// time-varying values of a Summary metric. The count and sum fields represent +// cumulative values. +message SummaryDataPoint { + reserved 1; + + // 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). + // The behavior of software that receives duplicated keys can be unpredictable. + repeated opentelemetry.proto.common.v1.KeyValue attributes = 7; + + // 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. + fixed64 start_time_unix_nano = 2; + + // 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. + fixed64 time_unix_nano = 3; + + // count is the number of values in the population. Must be non-negative. + fixed64 count = 4; + + // 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/prometheus/OpenMetrics/blob/v1.0.0/specification/OpenMetrics.md#summary + double sum = 5; + + // Represents the value at a given quantile of a distribution. + // + // To record Min and Max values following conventions are used: + // - The 1.0 quantile is equivalent to the maximum value observed. + // - The 0.0 quantile is equivalent to the minimum value observed. + // + // See the following issue for more context: + // https://github.com/open-telemetry/opentelemetry-proto/issues/125 + message ValueAtQuantile { + // The quantile of a distribution. Must be in the interval + // [0.0, 1.0]. + double quantile = 1; + + // The value at the given quantile of a distribution. + // + // Quantile values must NOT be negative. + double value = 2; + } + + // (Optional) list of values at different quantiles of the distribution calculated + // from the current snapshot. The quantiles must be strictly increasing. + repeated ValueAtQuantile quantile_values = 6; + + // Flags that apply to this specific data point. See DataPointFlags + // for the available flags and their meaning. + uint32 flags = 8; +} + +// A representation of an exemplar, which is a sample input measurement. +// Exemplars also hold information about the environment when the measurement +// was recorded, for example the span and trace ID of the active span when the +// exemplar was recorded. +message Exemplar { + reserved 1; + + // 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 + repeated opentelemetry.proto.common.v1.KeyValue filtered_attributes = 7; + + // 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. + fixed64 time_unix_nano = 2; + + // The value of the measurement that was recorded. An exemplar is + // considered invalid when one of the recognized value fields is not present + // inside this oneof. + oneof value { + double as_double = 3; + sfixed64 as_int = 6; + } + + // (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. + bytes span_id = 4; + + // (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. + bytes trace_id = 5; +} diff --git a/modules/sync/opentelemetry/opentelemetry/cas/85f2d08e7658716fa12e3708b38b4ee4d6dbb4138a483fee082247e174dfd5580d5ba485ec6bc3b3c6d0fc54ba992c0bdfbc25cff1d7a49f51cd2a1ccfd0a591 b/modules/sync/opentelemetry/opentelemetry/cas/85f2d08e7658716fa12e3708b38b4ee4d6dbb4138a483fee082247e174dfd5580d5ba485ec6bc3b3c6d0fc54ba992c0bdfbc25cff1d7a49f51cd2a1ccfd0a591 new file mode 100644 index 00000000..0baded11 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/85f2d08e7658716fa12e3708b38b4ee4d6dbb4138a483fee082247e174dfd5580d5ba485ec6bc3b3c6d0fc54ba992c0bdfbc25cff1d7a49f51cd2a1ccfd0a591 @@ -0,0 +1,82 @@ +// Copyright 2023, OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package opentelemetry.proto.collector.profiles.v1development; + +import "opentelemetry/proto/profiles/v1development/profiles.proto"; + +option csharp_namespace = "OpenTelemetry.Proto.Collector.Profiles.V1Development"; +option java_multiple_files = true; +option java_package = "io.opentelemetry.proto.collector.profiles.v1development"; +option java_outer_classname = "ProfilesServiceProto"; +option go_package = "go.opentelemetry.io/proto/otlp/collector/profiles/v1development"; + +// Service that can be used to push profiles between one Application instrumented with +// OpenTelemetry and a collector, or between a collector and a central collector. +service ProfilesService { + rpc Export(ExportProfilesServiceRequest) returns (ExportProfilesServiceResponse) {} +} + +// Status: [Alpha] +message ExportProfilesServiceRequest { + // An array of ResourceProfiles. + // For data coming from a single resource this array will typically contain one + // element. Intermediary nodes (such as OpenTelemetry Collector) that receive + // data from multiple origins typically batch the data before forwarding further and + // in that case this array will contain multiple elements. + repeated opentelemetry.proto.profiles.v1development.ResourceProfiles resource_profiles = 1; + + // The reference table containing all data shared by profiles across the message being sent. + opentelemetry.proto.profiles.v1development.ProfilesDictionary dictionary = 2; +} + +// Status: [Alpha] +message ExportProfilesServiceResponse { + // The details of a partially successful export request. + // + // If the request is only partially accepted + // (i.e. when the server accepts only parts of the data and rejects the rest) + // the server MUST initialize the `partial_success` field and MUST + // set the `rejected_` with the number of items it rejected. + // + // Servers MAY also make use of the `partial_success` field to convey + // warnings/suggestions to senders even when the request was fully accepted. + // In such cases, the `rejected_` MUST have a value of `0` and + // the `error_message` MUST be non-empty. + // + // A `partial_success` message with an empty value (rejected_ = 0 and + // `error_message` = "") is equivalent to it not being set/present. Senders + // SHOULD interpret it the same way as in the full success case. + ExportProfilesPartialSuccess partial_success = 1; +} + +// Status: [Alpha] +message ExportProfilesPartialSuccess { + // The number of rejected profiles. + // + // A `rejected_` field holding a `0` value indicates that the + // request was fully accepted. + int64 rejected_profiles = 1; + + // A developer-facing human-readable message in English. It should be used + // either to explain why the server rejected parts of the data during a partial + // success or to convey warnings/suggestions during a full success. The message + // should offer guidance on how users can address such issues. + // + // error_message is an optional field. An error_message with an empty value + // is equivalent to it not being set. + string error_message = 2; +} diff --git a/modules/sync/opentelemetry/opentelemetry/cas/b4c21f5721b64e4e8c7f871314cdebfeb1fe7e423cef183990365a892f596808b7d4e02af6a9860334684f787c1feffb1b661d19ba71aad507cc2c6b456c46db b/modules/sync/opentelemetry/opentelemetry/cas/b4c21f5721b64e4e8c7f871314cdebfeb1fe7e423cef183990365a892f596808b7d4e02af6a9860334684f787c1feffb1b661d19ba71aad507cc2c6b456c46db new file mode 100644 index 00000000..1b8d5b71 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/b4c21f5721b64e4e8c7f871314cdebfeb1fe7e423cef183990365a892f596808b7d4e02af6a9860334684f787c1feffb1b661d19ba71aad507cc2c6b456c46db @@ -0,0 +1,14 @@ +shake256:faedd41bb62749fa9e3e87f183fe58065f0d4ccf60e4d347727c04544ccdd08a43f1703d8f2cd31613fe1a767d63c33b280f34df99eda6ad2b25dfec4c4ead81 LICENSE +shake256:2c4433c14b51cf40358b2c22ed9f6335ca4e76831b0d12dd887e6cc3c2c87afd652d2159ff8b1c29512c1c2ada9aa67c066d7d298823b815453f6609b2f0513d buf.md +shake256:129b5bb5b6320c82c55be1b47431cec3bb560b65fef63a6e4e86ee083fd3778bb18673f7bf8811e51bf28e1fad3f5a7b4a0cbbd99d26f7bb5248a2ee51de3dce buf.yaml +shake256:a95600b2eccdb1943ae6218d949a4d90d2b8da739e98c95da574e55fec7b5f341aebfaa62ebc636202625413b84999d89f30b41c133ad1050930a08e71e6cc52 opentelemetry/proto/collector/logs/v1/logs_service.proto +shake256:78f3509da253b5b4146522e239727b99c47b0a2b04594cac3494ed155777e5e63536f97b33f71639607f1e5ec0ead37d4b0b77536c6ecd4d58839338be19bce0 opentelemetry/proto/collector/metrics/v1/metrics_service.proto +shake256:85f2d08e7658716fa12e3708b38b4ee4d6dbb4138a483fee082247e174dfd5580d5ba485ec6bc3b3c6d0fc54ba992c0bdfbc25cff1d7a49f51cd2a1ccfd0a591 opentelemetry/proto/collector/profiles/v1development/profiles_service.proto +shake256:45484b5a296e7ce8b5420d7031909bf762f020daf6bff80b8eee794e2213b838f93ca3c920a529f4bb62889b49a734f35be032bce9caa51dd955b4f10ca52e51 opentelemetry/proto/collector/trace/v1/trace_service.proto +shake256:097bbf1f07eb73ba289ea12b5727283166d08239d702030db2dcce8b3ea1878c6db621b1d2a95e6354977c1c471cba1267f8fa0636c4b79d32c2d8d80512b0c9 opentelemetry/proto/common/v1/common.proto +shake256:81fe4439e35a85ecda4b271e886e1cf8bda24a952a8acef1cafc1891140276f82623e1f651258fbb42cf87bb355629d4d449199b8919892e58d4b82a5e0ff4aa opentelemetry/proto/logs/v1/logs.proto +shake256:57b8c0a8cdeaf2d041aae974946f4bf0c0da3a92ef7556d9547985690a793e070527a9ace5932153cdf4f4ba870207eba72e9702cc1efb45bf885ab9bffc758b opentelemetry/proto/metrics/v1/metrics.proto +shake256:0d1c9369ac685e0bdc1ffbe2744e2f07498168af5e6f82270701cb0a6f44f6775556c19b84b7bd7630512659c68c7bc7d4160d5a5a63fec9a823c372dca2d23c opentelemetry/proto/processcontext/v1development/process_context.proto +shake256:16bccfa8028eb699701b6fb14599348de2a9a239bcb56c55a4ad11ec2a835f5e5848f8ac000c52890bad71a2722e369ee409a37ef4ef3e1dabc76884484579ec opentelemetry/proto/profiles/v1development/profiles.proto +shake256:8dee2b711709c2bb2b4aae0e587fd0e557c72d0ecdba6e4f4a463b87ca995fe91f6a0eb6d9246c01e2172ee33a911501f7aadb094fc5952020c4d1cb361fc7af opentelemetry/proto/resource/v1/resource.proto +shake256:daf84eb52a7672684ee2e42f1d1c95689157356721f234a0dcf990ce62d138368a7968a03169551c154f3ca0ef3b94dea95f1b3ec07c7c4dfe74cf6e9ba99899 opentelemetry/proto/trace/v1/trace.proto diff --git a/modules/sync/opentelemetry/opentelemetry/state.json b/modules/sync/opentelemetry/opentelemetry/state.json index aa3f8435..2f22cc10 100644 --- a/modules/sync/opentelemetry/opentelemetry/state.json +++ b/modules/sync/opentelemetry/opentelemetry/state.json @@ -35,6 +35,10 @@ { "name": "v1.10.0", "digest": "1a1c76b9fb39277f441fa81273e5132e2856558fd52b04e3ea69051f6ecdb5293e35c8915ec7e20507bba9d4bb6b0ba9a1408062fa63dd7f09db015ad06736ab" + }, + { + "name": "v1.11.0", + "digest": "b4c21f5721b64e4e8c7f871314cdebfeb1fe7e423cef183990365a892f596808b7d4e02af6a9860334684f787c1feffb1b661d19ba71aad507cc2c6b456c46db" } ] } \ No newline at end of file diff --git a/modules/sync/state.json b/modules/sync/state.json index 6ca41ac4..c62cd497 100644 --- a/modules/sync/state.json +++ b/modules/sync/state.json @@ -42,11 +42,11 @@ }, { "module_name": "googleapis/cloud-run", - "latest_reference": "5f933a6c53e57f87e47e3725fceca08cf24b5b16" + "latest_reference": "38046d1d720f00070ea976c5aa6a3e3954c9b8c3" }, { "module_name": "googleapis/googleapis", - "latest_reference": "5f933a6c53e57f87e47e3725fceca08cf24b5b16" + "latest_reference": "38046d1d720f00070ea976c5aa6a3e3954c9b8c3" }, { "module_name": "googlechrome/lighthouse", @@ -70,7 +70,7 @@ }, { "module_name": "opentelemetry/opentelemetry", - "latest_reference": "v1.10.0" + "latest_reference": "v1.11.0" }, { "module_name": "prometheus/client-model",