diff --git a/modules/sync/cncf/xds/state.json b/modules/sync/cncf/xds/state.json index 6c727c46..ffe80405 100644 --- a/modules/sync/cncf/xds/state.json +++ b/modules/sync/cncf/xds/state.json @@ -139,6 +139,10 @@ { "name": "0feb69152e9f7e8a45c8a3cfe8c7dd93bca3512f", "digest": "2a5d2cce987de374cf765ec5ec2f2435fe9fdc3d8a638dd26d92ce3130b7971d38894e406d8b42504890afafb45a277f492dad91f16ae5114e6486876fbff2c2" + }, + { + "name": "5cf4b19495289a9e992ce5e2c3ffb08f2cf387be", + "digest": "2a5d2cce987de374cf765ec5ec2f2435fe9fdc3d8a638dd26d92ce3130b7971d38894e406d8b42504890afafb45a277f492dad91f16ae5114e6486876fbff2c2" } ] } \ No newline at end of file diff --git a/modules/sync/google/cel-spec/cas/11d6e6f8e4c7b6178c0bc77833416b2621c3e52e179e26968640a8853ac582c3f262dfc5f81203b9827625f0c0bcfbdd0530f6be02025d4a15078b4bb6f04ecd b/modules/sync/google/cel-spec/cas/11d6e6f8e4c7b6178c0bc77833416b2621c3e52e179e26968640a8853ac582c3f262dfc5f81203b9827625f0c0bcfbdd0530f6be02025d4a15078b4bb6f04ecd new file mode 100644 index 00000000..9f2071ca --- /dev/null +++ b/modules/sync/google/cel-spec/cas/11d6e6f8e4c7b6178c0bc77833416b2621c3e52e179e26968640a8853ac582c3f262dfc5f81203b9827625f0c0bcfbdd0530f6be02025d4a15078b4bb6f04ecd @@ -0,0 +1,16 @@ +shake256:a9c4ad5b20a2946a25d5efb7f096b32ffaa567e3e9a7d89984870104aab45f08d7f6f10c7c72affdc4aabab0471066958ae97c3bb5925b7cb268f8afde27ebbf LICENSE +shake256:f919be9d99e84834dda39128ab7e5dc933b1dd06d313ce5862d45f659ada950cb3e41f4ed433adc05b5b7d1a99fa481aace6dbebb0548519d717f30727fc7c2c buf.md +shake256:4cee2ac14720719f03ed99dc8ee8f7251434ea67a611ff328b924c602115db40ce68472bfb25113b2a597c88b26d33b5dd87f8d9fe7602a756dc9fd849e24a31 buf.yaml +shake256:4c748900447cb6d800a633a9025d9ddcb92cb359109df89743026c8cd160015f1b01a1ae3bd655b40bf27c48453b772c17aac592d15bbeb9ceefb2db8c25a442 cel/expr/checked.proto +shake256:5669298dae92218958cbf0c0808ff51717bc92bf3ed915c49824ce1c8814315371744a0c662d33acea5da8106e31ba09746ad5c91e098e63a0b2dd56233c085c cel/expr/conformance/conformance_service.proto +shake256:bd50ff2443ef612045795243b0fbb52cf5f2e4a298ba1fce88afc404dcb456509611e0221e13a2f74f3a2eaa93736cad24867d2153b8bf87e85e45f8b4b3c3d8 cel/expr/conformance/env_config.proto +shake256:a6615c18655349b56868b0042e5e7fe2707c9c7ab8ceda66e2d591aba303d0ce551972c0ed0a74e16e0ca8e79e6d7f9cad05c889d83df45157c3e019a3965e09 cel/expr/conformance/proto2/test_all_types.proto +shake256:f99521a71c07c7718d21535c66f940eef007b392bfa399516067f4747542d0f09c93f7985694033a972d95d17f48efd7db24f135f02d91d918609865d5c5b5ac cel/expr/conformance/proto2/test_all_types_extensions.proto +shake256:f8e60b6c999e660968f9c6a28ded0312e970fa95ff4f4939dfbdd7c898630010d734706703185fc31e04612d4002c19ae524afa5fcddbe9087e35e0f133f8ac0 cel/expr/conformance/proto3/test_all_types.proto +shake256:8051137bfcd73e293945c4efba7085132f908b8b93bcca23ef6d68547c4df65a38b33015b9f1887299eff238fd09c1a964fe606e1cf73a4fbe4fe1dc954fedf4 cel/expr/conformance/test/simple.proto +shake256:bc6a7add87d28e3ca499f22335fd722b55ba86cc06d2375d2cebc637b805be729ef8a873c1a925b73e0c118b3c3d866953f15a057d277e3c30aaa96922bae762 cel/expr/conformance/test/suite.proto +shake256:8254940a7e6402e4271da7bc4473d4829c81c7f4426ca04e02cee134dddfb0215833113c683bb4b8b29b7c329f80c5aa4e901c0bc3bcb8a12e60eea093e7824f cel/expr/eval.proto +shake256:01031ca65d7c98fab0b1eebd130adb13130b12099bf077697a5c67deaa2c96fd0807a84369963c72537c49a39f7a003c43f750d19b46e9236216acf28764d5ca cel/expr/explain.proto +shake256:2f714e608581f3865ab1687caed197ec214d626422e5655c21b7b3f9f8acc3b9deda7d87b62731936d08ed3049087517e24b6ac68c19e288277228c258c3876a cel/expr/syntax.proto +shake256:2422598f36b5b5d874b3684a49c02ef87bc152eeb94adc054ca7eaf7c8aab87764546dfdf0f039b3c0b1012f231abc494e4a2b52cda7851573fade5355de1cd7 cel/expr/value.proto +shake256:237c020d857e552a5697630122d2562ae4a55dbd743fcf91e787592df63f4a4e71af8237c14e5ddf3cb38eecf5b5e3cb28ad7e7816c142813807de2fa44f960d cel/policy/policy.proto diff --git a/modules/sync/google/cel-spec/cas/237c020d857e552a5697630122d2562ae4a55dbd743fcf91e787592df63f4a4e71af8237c14e5ddf3cb38eecf5b5e3cb28ad7e7816c142813807de2fa44f960d b/modules/sync/google/cel-spec/cas/237c020d857e552a5697630122d2562ae4a55dbd743fcf91e787592df63f4a4e71af8237c14e5ddf3cb38eecf5b5e3cb28ad7e7816c142813807de2fa44f960d new file mode 100644 index 00000000..e6a45f9f --- /dev/null +++ b/modules/sync/google/cel-spec/cas/237c020d857e552a5697630122d2562ae4a55dbd743fcf91e787592df63f4a4e71af8237c14e5ddf3cb38eecf5b5e3cb28ad7e7816c142813807de2fa44f960d @@ -0,0 +1,80 @@ +// Copyright 2025 Google LLC +// +// 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 cel.policy; + +option cc_enable_arenas = true; +option go_package = "cel.dev/policy"; +option java_multiple_files = true; +option java_package = "dev.cel.policy"; + +message PolicySpec { + message Import { + string name = 1; + } + + message Variable { + string name = 1; + + string description = 2; + + string expression = 3; + } + + message Rule { + string id = 1; + + string description = 2; + + repeated Variable variables = 3; + + repeated Match match = 4; + } + + message Match { + // If unset, the default is "true". + optional string condition = 1; + + oneof action { + string output = 2; + + Rule rule = 3; + } + + string explanation = 4; + } + + string name = 1; + + repeated Import imports = 2; + + // If set, [PolicySpec][match] and [PolicySpec][rule] must be unset. + repeated Variable variables = 3; + // If set, [PolicySpec][match] and [PolicySpec][rule] must be unset. + optional string output = 4; + // If set, [PolicySpec][match] and [PolicySpec][rule] must be unset. + optional string description = 5; + // If set, [PolicySpec][match] and [PolicySpec][rule] must be unset. + optional string explanation = 6; + + // If set, [PolicySpec][variables], [PolicySpec][output], [PolicySpec][description], + // [PolicySpec][explanation], and [PolicySpec][rule] must be unset. + repeated Match match = 7; + + // If set, [PolicySpec][variables], [PolicySpec][output], [PolicySpec][description], + // [PolicySpec][explanation], and [PolicySpec][match] must be unset. + Rule rule = 8; +} diff --git a/modules/sync/google/cel-spec/cas/5669298dae92218958cbf0c0808ff51717bc92bf3ed915c49824ce1c8814315371744a0c662d33acea5da8106e31ba09746ad5c91e098e63a0b2dd56233c085c b/modules/sync/google/cel-spec/cas/5669298dae92218958cbf0c0808ff51717bc92bf3ed915c49824ce1c8814315371744a0c662d33acea5da8106e31ba09746ad5c91e098e63a0b2dd56233c085c new file mode 100644 index 00000000..2564c10d --- /dev/null +++ b/modules/sync/google/cel-spec/cas/5669298dae92218958cbf0c0808ff51717bc92bf3ed915c49824ce1c8814315371744a0c662d33acea5da8106e31ba09746ad5c91e098e63a0b2dd56233c085c @@ -0,0 +1,179 @@ +// Copyright 2022 Google LLC +// +// 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 cel.expr.conformance; + +import "cel/expr/checked.proto"; +import "cel/expr/eval.proto"; +import "cel/expr/syntax.proto"; + +option cc_enable_arenas = true; +option go_package = "cel.dev/expr/conformance"; +option java_multiple_files = true; +option java_outer_classname = "ConformanceServiceProto"; +option java_package = "dev.cel.expr.conformance"; + +// Access a CEL implementation from another process or machine. +// A CEL implementation is decomposed as a parser, a static checker, +// and an evaluator. Every CEL implementation is expected to provide +// a server for this API. The API will be used for conformance testing +// and other utilities. +service ConformanceService { + // Transforms CEL source text into a parsed representation. + rpc Parse(ParseRequest) returns (ParseResponse) { + } + + // Runs static checks on a parsed CEL representation and return + // an annotated representation, or a set of issues. + rpc Check(CheckRequest) returns (CheckResponse) { + } + + // Evaluates a parsed or annotation CEL representation given + // values of external bindings. + rpc Eval(EvalRequest) returns (EvalResponse) { + } +} + +// Request message for the Parse method. +message ParseRequest { + // Required. Source text in CEL syntax. + string cel_source = 1; + + // Tag for version of CEL syntax, for future use. + string syntax_version = 2; + + // File or resource for source text, used in [SourceInfo][google.api.SourceInfo]. + string source_location = 3; + + // Prevent macro expansion. See "Macros" in Language Defiinition. + bool disable_macros = 4; +} + +// Response message for the Parse method. +message ParseResponse { + // The parsed representation, or unset if parsing failed. + cel.expr.ParsedExpr parsed_expr = 1; + + // Any number of issues with [StatusDetails][] as the details. + cel.expr.ErrorSet issues = 2; +} + +// Request message for the Check method. +message CheckRequest { + // Required. The parsed representation of the CEL program. + cel.expr.ParsedExpr parsed_expr = 1; + + // Declarations of types for external variables and functions. + // Required if program uses external variables or functions + // not in the default environment. + repeated cel.expr.Decl type_env = 2; + + // The protocol buffer context. See "Name Resolution" in the + // Language Definition. + string container = 3; + + // If true, use only the declarations in [type_env][cel.expr.conformance.CheckRequest.type_env]. If false (default), + // add declarations for the standard definitions to the type environment. See + // "Standard Definitions" in the Language Definition. + bool no_std_env = 4; +} + +// Response message for the Check method. +message CheckResponse { + // The annotated representation, or unset if checking failed. + cel.expr.CheckedExpr checked_expr = 1; + + // Any number of issues with [StatusDetails][] as the details. + cel.expr.ErrorSet issues = 2; +} + +// Request message for the Eval method. +message EvalRequest { + // Required. Either the parsed or annotated representation of the CEL program. + oneof expr_kind { + // Evaluate based on the parsed representation. + cel.expr.ParsedExpr parsed_expr = 1; + + // Evaluate based on the checked representation. + cel.expr.CheckedExpr checked_expr = 2; + } + + // Bindings for the external variables. The types SHOULD be compatible + // with the type environment in [CheckRequest][cel.expr.conformance.CheckRequest], if checked. + map bindings = 3; + + // SHOULD be the same container as used in [CheckRequest][cel.expr.conformance.CheckRequest], if checked. + string container = 4; +} + +// Response message for the Eval method. +message EvalResponse { + // The execution result, or unset if execution couldn't start. + cel.expr.ExprValue result = 1; + + // Any number of issues with [StatusDetails][] as the details. + // Note that CEL execution errors are reified into [ExprValue][]. + // Nevertheless, we'll allow out-of-band issues to be raised, + // which also makes the replies more regular. + cel.expr.ErrorSet issues = 2; +} + +// A specific position in source. +message SourcePosition { + // The source location name (e.g. file name). + string location = 1; + + // The UTF-8 code unit offset. + int32 offset = 2; + + // The 1-based index of the starting line in the source text + // where the issue occurs, or 0 if unknown. + int32 line = 3; + + // The 0-based index of the starting position within the line of source text + // where the issue occurs. Only meaningful if line is nonzero. + int32 column = 4; +} + +// Warnings or errors in service execution are represented by +// [google.rpc.Status][google.rpc.Status] messages, with the following message +// in the details field. +message IssueDetails { + // Severities of issues. + enum Severity { + // An unspecified severity. + SEVERITY_UNSPECIFIED = 0; + + // Deprecation issue for statements and method that may no longer be + // supported or maintained. + DEPRECATION = 1; + + // Warnings such as: unused variables. + WARNING = 2; + + // Errors such as: unmatched curly braces or variable redefinition. + ERROR = 3; + } + + // The severity of the issue. + Severity severity = 1; + + // Position in the source, if known. + SourcePosition position = 2; + + // Expression ID from [Expr][], 0 if unknown. + int64 id = 3; +} diff --git a/modules/sync/google/cel-spec/cas/a6615c18655349b56868b0042e5e7fe2707c9c7ab8ceda66e2d591aba303d0ce551972c0ed0a74e16e0ca8e79e6d7f9cad05c889d83df45157c3e019a3965e09 b/modules/sync/google/cel-spec/cas/a6615c18655349b56868b0042e5e7fe2707c9c7ab8ceda66e2d591aba303d0ce551972c0ed0a74e16e0ca8e79e6d7f9cad05c889d83df45157c3e019a3965e09 new file mode 100644 index 00000000..620a1e4f --- /dev/null +++ b/modules/sync/google/cel-spec/cas/a6615c18655349b56868b0042e5e7fe2707c9c7ab8ceda66e2d591aba303d0ce551972c0ed0a74e16e0ca8e79e6d7f9cad05c889d83df45157c3e019a3965e09 @@ -0,0 +1,360 @@ +// Copyright 2024 Google LLC +// +// 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 = "proto2"; + +package cel.expr.conformance.proto2; + +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/empty.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +option cc_enable_arenas = true; +option go_package = "cel.dev/expr/conformance/proto2"; +option java_multiple_files = true; +option java_outer_classname = "TestAllTypesProto"; +option java_package = "dev.cel.expr.conformance.proto2"; + +// This proto includes every type of field in both singular and repeated +// forms. +message TestAllTypes { + message NestedMessage { + // The field name "b" fails to compile in proto1 because it conflicts with + // a local variable named "b" in one of the generated methods. + // This file needs to compile in proto1 to test backwards-compatibility. + optional int32 bb = 1; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + } + + // Singular + optional int32 single_int32 = 1 [default = -32]; + optional int64 single_int64 = 2 [default = -64]; + optional uint32 single_uint32 = 3 [default = 32]; + optional uint64 single_uint64 = 4 [default = 64]; + optional sint32 single_sint32 = 5; + optional sint64 single_sint64 = 6; + optional fixed32 single_fixed32 = 7; + optional fixed64 single_fixed64 = 8; + optional sfixed32 single_sfixed32 = 9; + optional sfixed64 single_sfixed64 = 10; + optional float single_float = 11 [default = 3.0]; + optional double single_double = 12 [default = 6.4]; + optional bool single_bool = 13 [default = true]; + optional string single_string = 14 [default = "empty"]; + optional bytes single_bytes = 15 [default = "none"]; + + // Collides with 'in' operator. + optional bool in = 18; + + // Wellknown. + optional google.protobuf.Any single_any = 100; + optional google.protobuf.Duration single_duration = 101; + optional google.protobuf.Timestamp single_timestamp = 102; + optional google.protobuf.Struct single_struct = 103; + optional google.protobuf.Value single_value = 104; + optional google.protobuf.Int64Value single_int64_wrapper = 105; + optional google.protobuf.Int32Value single_int32_wrapper = 106; + optional google.protobuf.DoubleValue single_double_wrapper = 107; + optional google.protobuf.FloatValue single_float_wrapper = 108; + optional google.protobuf.UInt64Value single_uint64_wrapper = 109; + optional google.protobuf.UInt32Value single_uint32_wrapper = 110; + optional google.protobuf.StringValue single_string_wrapper = 111; + optional google.protobuf.BoolValue single_bool_wrapper = 112; + optional google.protobuf.BytesValue single_bytes_wrapper = 113; + optional google.protobuf.ListValue list_value = 114; + optional google.protobuf.NullValue null_value = 115; + optional google.protobuf.NullValue optional_null_value = 116; + optional google.protobuf.FieldMask field_mask = 117; + optional google.protobuf.Empty empty = 118; + + // Nested messages + oneof nested_type { + NestedMessage single_nested_message = 21; + NestedEnum single_nested_enum = 22 [default = BAR]; + } + optional NestedMessage standalone_message = 23; + optional NestedEnum standalone_enum = 24; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + // Repeated and nested + repeated NestedMessage repeated_nested_message = 51; + repeated NestedEnum repeated_nested_enum = 52; + repeated string repeated_string_piece = 53 [ctype = STRING_PIECE]; + repeated string repeated_cord = 54 [ctype = CORD]; + repeated NestedMessage repeated_lazy_message = 55; + + // Repeated wellknown. + repeated google.protobuf.Any repeated_any = 120; + repeated google.protobuf.Duration repeated_duration = 121; + repeated google.protobuf.Timestamp repeated_timestamp = 122; + repeated google.protobuf.Struct repeated_struct = 123; + repeated google.protobuf.Value repeated_value = 124; + repeated google.protobuf.Int64Value repeated_int64_wrapper = 125; + repeated google.protobuf.Int32Value repeated_int32_wrapper = 126; + repeated google.protobuf.DoubleValue repeated_double_wrapper = 127; + repeated google.protobuf.FloatValue repeated_float_wrapper = 128; + repeated google.protobuf.UInt64Value repeated_uint64_wrapper = 129; + repeated google.protobuf.UInt32Value repeated_uint32_wrapper = 130; + repeated google.protobuf.StringValue repeated_string_wrapper = 131; + repeated google.protobuf.BoolValue repeated_bool_wrapper = 132; + repeated google.protobuf.BytesValue repeated_bytes_wrapper = 133; + repeated google.protobuf.ListValue repeated_list_value = 134; + repeated google.protobuf.NullValue repeated_null_value = 135; + + // Map + map map_int64_nested_type = 62; + + map map_bool_bool = 63; + map map_bool_string = 64; + map map_bool_bytes = 65; + map map_bool_int32 = 66; + map map_bool_int64 = 67; + map map_bool_uint32 = 68; + map map_bool_uint64 = 69; + map map_bool_float = 70; + map map_bool_double = 71; + map map_bool_enum = 72; + map map_bool_message = 73; + map map_bool_duration = 228; + map map_bool_timestamp = 229; + map map_bool_null_value = 230; + map map_bool_any = 246; + map map_bool_struct = 247; + map map_bool_value = 248; + map map_bool_list_value = 249; + map map_bool_int64_wrapper = 250; + map map_bool_int32_wrapper = 251; + map map_bool_double_wrapper = 252; + map map_bool_float_wrapper = 253; + map map_bool_uint64_wrapper = 254; + map map_bool_uint32_wrapper = 255; + map map_bool_string_wrapper = 256; + map map_bool_bool_wrapper = 257; + map map_bool_bytes_wrapper = 258; + + map map_int32_bool = 74; + map map_int32_string = 75; + map map_int32_bytes = 76; + map map_int32_int32 = 77; + map map_int32_int64 = 78; + map map_int32_uint32 = 79; + map map_int32_uint64 = 80; + map map_int32_float = 81; + map map_int32_double = 82; + map map_int32_enum = 83; + map map_int32_message = 84; + map map_int32_duration = 231; + map map_int32_timestamp = 232; + map map_int32_null_value = 233; + map map_int32_any = 259; + map map_int32_struct = 260; + map map_int32_value = 261; + map map_int32_list_value = 262; + map map_int32_int64_wrapper = 263; + map map_int32_int32_wrapper = 264; + map map_int32_double_wrapper = 265; + map map_int32_float_wrapper = 266; + map map_int32_uint64_wrapper = 267; + map map_int32_uint32_wrapper = 268; + map map_int32_string_wrapper = 269; + map map_int32_bool_wrapper = 270; + map map_int32_bytes_wrapper = 271; + + map map_int64_bool = 85; + map map_int64_string = 86; + map map_int64_bytes = 87; + map map_int64_int32 = 88; + map map_int64_int64 = 89; + map map_int64_uint32 = 90; + map map_int64_uint64 = 91; + map map_int64_float = 92; + map map_int64_double = 93; + map map_int64_enum = 94; + map map_int64_message = 95; + map map_int64_duration = 234; + map map_int64_timestamp = 235; + map map_int64_null_value = 236; + map map_int64_any = 272; + map map_int64_struct = 273; + map map_int64_value = 274; + map map_int64_list_value = 275; + map map_int64_int64_wrapper = 276; + map map_int64_int32_wrapper = 277; + map map_int64_double_wrapper = 278; + map map_int64_float_wrapper = 279; + map map_int64_uint64_wrapper = 280; + map map_int64_uint32_wrapper = 281; + map map_int64_string_wrapper = 282; + map map_int64_bool_wrapper = 283; + map map_int64_bytes_wrapper = 284; + + map map_uint32_bool = 96; + map map_uint32_string = 97; + map map_uint32_bytes = 98; + map map_uint32_int32 = 99; + map map_uint32_int64 = 200; + map map_uint32_uint32 = 201; + map map_uint32_uint64 = 202; + map map_uint32_float = 203; + map map_uint32_double = 204; + map map_uint32_enum = 205; + map map_uint32_message = 206; + map map_uint32_duration = 237; + map map_uint32_timestamp = 238; + map map_uint32_null_value = 239; + map map_uint32_any = 285; + map map_uint32_struct = 286; + map map_uint32_value = 287; + map map_uint32_list_value = 288; + map map_uint32_int64_wrapper = 289; + map map_uint32_int32_wrapper = 290; + map map_uint32_double_wrapper = 291; + map map_uint32_float_wrapper = 292; + map map_uint32_uint64_wrapper = 293; + map map_uint32_uint32_wrapper = 294; + map map_uint32_string_wrapper = 295; + map map_uint32_bool_wrapper = 296; + map map_uint32_bytes_wrapper = 297; + + map map_uint64_bool = 207; + map map_uint64_string = 208; + map map_uint64_bytes = 209; + map map_uint64_int32 = 210; + map map_uint64_int64 = 211; + map map_uint64_uint32 = 212; + map map_uint64_uint64 = 213; + map map_uint64_float = 214; + map map_uint64_double = 215; + map map_uint64_enum = 216; + map map_uint64_message = 217; + map map_uint64_duration = 240; + map map_uint64_timestamp = 241; + map map_uint64_null_value = 242; + map map_uint64_any = 298; + map map_uint64_struct = 299; + map map_uint64_value = 300; + map map_uint64_list_value = 301; + map map_uint64_int64_wrapper = 302; + map map_uint64_int32_wrapper = 303; + map map_uint64_double_wrapper = 304; + map map_uint64_float_wrapper = 305; + map map_uint64_uint64_wrapper = 306; + map map_uint64_uint32_wrapper = 307; + map map_uint64_string_wrapper = 308; + map map_uint64_bool_wrapper = 309; + map map_uint64_bytes_wrapper = 310; + + map map_string_bool = 218; + map map_string_string = 61; + map map_string_bytes = 219; + map map_string_int32 = 220; + map map_string_int64 = 221; + map map_string_uint32 = 222; + map map_string_uint64 = 223; + map map_string_float = 224; + map map_string_double = 225; + map map_string_enum = 226; + map map_string_message = 227; + map map_string_duration = 243; + map map_string_timestamp = 244; + map map_string_null_value = 245; + map map_string_any = 311; + map map_string_struct = 312; + map map_string_value = 313; + map map_string_list_value = 314; + map map_string_int64_wrapper = 315; + map map_string_int32_wrapper = 316; + map map_string_double_wrapper = 317; + map map_string_float_wrapper = 318; + map map_string_uint64_wrapper = 319; + map map_string_uint32_wrapper = 320; + map map_string_string_wrapper = 321; + map map_string_bool_wrapper = 322; + map map_string_bytes_wrapper = 323; + + oneof kind { + NestedTestAllTypes oneof_type = 400; + NestedMessage oneof_msg = 401; + bool oneof_bool = 402; + } + + optional group NestedGroup = 403 { + optional int32 single_id = 404; + optional string single_name = 405; + } + + // Field names formerly defined as reserved CEL identifiers. + optional bool as = 500; + optional bool break = 501; + optional bool const = 502; + optional bool continue = 503; + optional bool else = 504; + optional bool for = 505; + optional bool function = 506; + optional bool if = 507; + optional bool import = 508; + optional bool let = 509; + optional bool loop = 510; + optional bool package = 511; + optional bool namespace = 512; + optional bool return = 513; + optional bool var = 514; + optional bool void = 515; + optional bool while = 516; + + extensions 1000 to max; +} + +// This proto includes a recursively nested message. +message NestedTestAllTypes { + optional NestedTestAllTypes child = 1; + optional TestAllTypes payload = 2; +} + +// This proto has a required field. +message TestRequired { + required int32 required_int32 = 1; +} + +// This proto tests that global enums are resolved correctly. +enum GlobalEnum { + GOO = 0; + GAR = 1; + GAZ = 2; +} diff --git a/modules/sync/google/cel-spec/cas/f8e60b6c999e660968f9c6a28ded0312e970fa95ff4f4939dfbdd7c898630010d734706703185fc31e04612d4002c19ae524afa5fcddbe9087e35e0f133f8ac0 b/modules/sync/google/cel-spec/cas/f8e60b6c999e660968f9c6a28ded0312e970fa95ff4f4939dfbdd7c898630010d734706703185fc31e04612d4002c19ae524afa5fcddbe9087e35e0f133f8ac0 new file mode 100644 index 00000000..ff6f31a8 --- /dev/null +++ b/modules/sync/google/cel-spec/cas/f8e60b6c999e660968f9c6a28ded0312e970fa95ff4f4939dfbdd7c898630010d734706703185fc31e04612d4002c19ae524afa5fcddbe9087e35e0f133f8ac0 @@ -0,0 +1,350 @@ +// Copyright 2024 Google LLC +// +// 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 cel.expr.conformance.proto3; + +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/empty.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +option cc_enable_arenas = true; +option go_package = "cel.dev/expr/conformance/proto3"; +option java_multiple_files = true; +option java_outer_classname = "TestAllTypesProto"; +option java_package = "dev.cel.expr.conformance.proto3"; + +// This proto includes every type of field in both singular and repeated +// forms. +message TestAllTypes { + message NestedMessage { + // The field name "b" fails to compile in proto1 because it conflicts with + // a local variable named "b" in one of the generated methods. + // This file needs to compile in proto1 to test backwards-compatibility. + int32 bb = 1; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + } + + // Singular + int32 single_int32 = 1; + int64 single_int64 = 2; + uint32 single_uint32 = 3; + uint64 single_uint64 = 4; + sint32 single_sint32 = 5; + sint64 single_sint64 = 6; + fixed32 single_fixed32 = 7; + fixed64 single_fixed64 = 8; + sfixed32 single_sfixed32 = 9; + sfixed64 single_sfixed64 = 10; + float single_float = 11; + double single_double = 12; + bool single_bool = 13; + string single_string = 14; + bytes single_bytes = 15; + optional bool optional_bool = 16; + optional string optional_string = 17; + + // Collides with 'in' operator. + bool in = 18; + + // Wellknown. + google.protobuf.Any single_any = 100; + google.protobuf.Duration single_duration = 101; + google.protobuf.Timestamp single_timestamp = 102; + google.protobuf.Struct single_struct = 103; + google.protobuf.Value single_value = 104; + google.protobuf.Int64Value single_int64_wrapper = 105; + google.protobuf.Int32Value single_int32_wrapper = 106; + google.protobuf.DoubleValue single_double_wrapper = 107; + google.protobuf.FloatValue single_float_wrapper = 108; + google.protobuf.UInt64Value single_uint64_wrapper = 109; + google.protobuf.UInt32Value single_uint32_wrapper = 110; + google.protobuf.StringValue single_string_wrapper = 111; + google.protobuf.BoolValue single_bool_wrapper = 112; + google.protobuf.BytesValue single_bytes_wrapper = 113; + google.protobuf.ListValue list_value = 114; + google.protobuf.NullValue null_value = 115; + optional google.protobuf.NullValue optional_null_value = 116; + google.protobuf.FieldMask field_mask = 117; + google.protobuf.Empty empty = 118; + + // Nested messages + oneof nested_type { + NestedMessage single_nested_message = 21; + NestedEnum single_nested_enum = 22; + } + NestedMessage standalone_message = 23; + NestedEnum standalone_enum = 24; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + // Repeated and nested + repeated NestedMessage repeated_nested_message = 51; + repeated NestedEnum repeated_nested_enum = 52; + repeated string repeated_string_piece = 53 [ctype = STRING_PIECE]; + repeated string repeated_cord = 54 [ctype = CORD]; + repeated NestedMessage repeated_lazy_message = 55; + + // Repeated wellknown. + repeated google.protobuf.Any repeated_any = 120; + repeated google.protobuf.Duration repeated_duration = 121; + repeated google.protobuf.Timestamp repeated_timestamp = 122; + repeated google.protobuf.Struct repeated_struct = 123; + repeated google.protobuf.Value repeated_value = 124; + repeated google.protobuf.Int64Value repeated_int64_wrapper = 125; + repeated google.protobuf.Int32Value repeated_int32_wrapper = 126; + repeated google.protobuf.DoubleValue repeated_double_wrapper = 127; + repeated google.protobuf.FloatValue repeated_float_wrapper = 128; + repeated google.protobuf.UInt64Value repeated_uint64_wrapper = 129; + repeated google.protobuf.UInt32Value repeated_uint32_wrapper = 130; + repeated google.protobuf.StringValue repeated_string_wrapper = 131; + repeated google.protobuf.BoolValue repeated_bool_wrapper = 132; + repeated google.protobuf.BytesValue repeated_bytes_wrapper = 133; + repeated google.protobuf.ListValue repeated_list_value = 134; + repeated google.protobuf.NullValue repeated_null_value = 135; + + // Map + map map_int64_nested_type = 62; + + map map_bool_bool = 63; + map map_bool_string = 64; + map map_bool_bytes = 65; + map map_bool_int32 = 66; + map map_bool_int64 = 67; + map map_bool_uint32 = 68; + map map_bool_uint64 = 69; + map map_bool_float = 70; + map map_bool_double = 71; + map map_bool_enum = 72; + map map_bool_message = 73; + map map_bool_duration = 228; + map map_bool_timestamp = 229; + map map_bool_null_value = 230; + map map_bool_any = 246; + map map_bool_struct = 247; + map map_bool_value = 248; + map map_bool_list_value = 249; + map map_bool_int64_wrapper = 250; + map map_bool_int32_wrapper = 251; + map map_bool_double_wrapper = 252; + map map_bool_float_wrapper = 253; + map map_bool_uint64_wrapper = 254; + map map_bool_uint32_wrapper = 255; + map map_bool_string_wrapper = 256; + map map_bool_bool_wrapper = 257; + map map_bool_bytes_wrapper = 258; + + map map_int32_bool = 74; + map map_int32_string = 75; + map map_int32_bytes = 76; + map map_int32_int32 = 77; + map map_int32_int64 = 78; + map map_int32_uint32 = 79; + map map_int32_uint64 = 80; + map map_int32_float = 81; + map map_int32_double = 82; + map map_int32_enum = 83; + map map_int32_message = 84; + map map_int32_duration = 231; + map map_int32_timestamp = 232; + map map_int32_null_value = 233; + map map_int32_any = 259; + map map_int32_struct = 260; + map map_int32_value = 261; + map map_int32_list_value = 262; + map map_int32_int64_wrapper = 263; + map map_int32_int32_wrapper = 264; + map map_int32_double_wrapper = 265; + map map_int32_float_wrapper = 266; + map map_int32_uint64_wrapper = 267; + map map_int32_uint32_wrapper = 268; + map map_int32_string_wrapper = 269; + map map_int32_bool_wrapper = 270; + map map_int32_bytes_wrapper = 271; + + map map_int64_bool = 85; + map map_int64_string = 86; + map map_int64_bytes = 87; + map map_int64_int32 = 88; + map map_int64_int64 = 89; + map map_int64_uint32 = 90; + map map_int64_uint64 = 91; + map map_int64_float = 92; + map map_int64_double = 93; + map map_int64_enum = 94; + map map_int64_message = 95; + map map_int64_duration = 234; + map map_int64_timestamp = 235; + map map_int64_null_value = 236; + map map_int64_any = 272; + map map_int64_struct = 273; + map map_int64_value = 274; + map map_int64_list_value = 275; + map map_int64_int64_wrapper = 276; + map map_int64_int32_wrapper = 277; + map map_int64_double_wrapper = 278; + map map_int64_float_wrapper = 279; + map map_int64_uint64_wrapper = 280; + map map_int64_uint32_wrapper = 281; + map map_int64_string_wrapper = 282; + map map_int64_bool_wrapper = 283; + map map_int64_bytes_wrapper = 284; + + map map_uint32_bool = 96; + map map_uint32_string = 97; + map map_uint32_bytes = 98; + map map_uint32_int32 = 99; + map map_uint32_int64 = 200; + map map_uint32_uint32 = 201; + map map_uint32_uint64 = 202; + map map_uint32_float = 203; + map map_uint32_double = 204; + map map_uint32_enum = 205; + map map_uint32_message = 206; + map map_uint32_duration = 237; + map map_uint32_timestamp = 238; + map map_uint32_null_value = 239; + map map_uint32_any = 285; + map map_uint32_struct = 286; + map map_uint32_value = 287; + map map_uint32_list_value = 288; + map map_uint32_int64_wrapper = 289; + map map_uint32_int32_wrapper = 290; + map map_uint32_double_wrapper = 291; + map map_uint32_float_wrapper = 292; + map map_uint32_uint64_wrapper = 293; + map map_uint32_uint32_wrapper = 294; + map map_uint32_string_wrapper = 295; + map map_uint32_bool_wrapper = 296; + map map_uint32_bytes_wrapper = 297; + + map map_uint64_bool = 207; + map map_uint64_string = 208; + map map_uint64_bytes = 209; + map map_uint64_int32 = 210; + map map_uint64_int64 = 211; + map map_uint64_uint32 = 212; + map map_uint64_uint64 = 213; + map map_uint64_float = 214; + map map_uint64_double = 215; + map map_uint64_enum = 216; + map map_uint64_message = 217; + map map_uint64_duration = 240; + map map_uint64_timestamp = 241; + map map_uint64_null_value = 242; + map map_uint64_any = 298; + map map_uint64_struct = 299; + map map_uint64_value = 300; + map map_uint64_list_value = 301; + map map_uint64_int64_wrapper = 302; + map map_uint64_int32_wrapper = 303; + map map_uint64_double_wrapper = 304; + map map_uint64_float_wrapper = 305; + map map_uint64_uint64_wrapper = 306; + map map_uint64_uint32_wrapper = 307; + map map_uint64_string_wrapper = 308; + map map_uint64_bool_wrapper = 309; + map map_uint64_bytes_wrapper = 310; + + map map_string_bool = 218; + map map_string_string = 61; + map map_string_bytes = 219; + map map_string_int32 = 220; + map map_string_int64 = 221; + map map_string_uint32 = 222; + map map_string_uint64 = 223; + map map_string_float = 224; + map map_string_double = 225; + map map_string_enum = 226; + map map_string_message = 227; + map map_string_duration = 243; + map map_string_timestamp = 244; + map map_string_null_value = 245; + map map_string_any = 311; + map map_string_struct = 312; + map map_string_value = 313; + map map_string_list_value = 314; + map map_string_int64_wrapper = 315; + map map_string_int32_wrapper = 316; + map map_string_double_wrapper = 317; + map map_string_float_wrapper = 318; + map map_string_uint64_wrapper = 319; + map map_string_uint32_wrapper = 320; + map map_string_string_wrapper = 321; + map map_string_bool_wrapper = 322; + map map_string_bytes_wrapper = 323; + + oneof kind { + NestedTestAllTypes oneof_type = 400; + NestedMessage oneof_msg = 401; + bool oneof_bool = 402; + } + + // Field names formerly defined as reserved CEL identifiers. + bool as = 500; + bool break = 501; + bool const = 502; + bool continue = 503; + bool else = 504; + bool for = 505; + bool function = 506; + bool if = 507; + bool import = 508; + bool let = 509; + bool loop = 510; + bool package = 511; + bool namespace = 512; + bool return = 513; + bool var = 514; + bool void = 515; + bool while = 516; +} + +// This proto includes a recursively nested message. +message NestedTestAllTypes { + NestedTestAllTypes child = 1; + TestAllTypes payload = 2; +} + +// This proto tests that global enums are resolved correctly. +enum GlobalEnum { + GOO = 0; + GAR = 1; + GAZ = 2; +} diff --git a/modules/sync/google/cel-spec/state.json b/modules/sync/google/cel-spec/state.json index c11b845e..8af5b919 100644 --- a/modules/sync/google/cel-spec/state.json +++ b/modules/sync/google/cel-spec/state.json @@ -79,6 +79,10 @@ { "name": "v0.24.0", "digest": "16658081a0551408bcf294985f36a3dee2b599d84570f04a9594633109ee5e66d4b5a7c43e6e3f3968022056316a43fdd43c3b197fe1b20584e5edfbdd512f72" + }, + { + "name": "v0.25.0", + "digest": "11d6e6f8e4c7b6178c0bc77833416b2621c3e52e179e26968640a8853ac582c3f262dfc5f81203b9827625f0c0bcfbdd0530f6be02025d4a15078b4bb6f04ecd" } ] } \ No newline at end of file diff --git a/modules/sync/opentelemetry/opentelemetry/cas/31f9ef66df2a709ffe84506dea5c5af1b02a524c2a8cd726e82cb5d76fe0b9421702e7f2434828aa4230d70745803cb0ca7c56592218db2facc5d9d08f321c9f b/modules/sync/opentelemetry/opentelemetry/cas/31f9ef66df2a709ffe84506dea5c5af1b02a524c2a8cd726e82cb5d76fe0b9421702e7f2434828aa4230d70745803cb0ca7c56592218db2facc5d9d08f321c9f new file mode 100644 index 00000000..a6af56d7 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/31f9ef66df2a709ffe84506dea5c5af1b02a524c2a8cd726e82cb5d76fe0b9421702e7f2434828aa4230d70745803cb0ca7c56592218db2facc5d9d08f321c9f @@ -0,0 +1,480 @@ +// 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 ┌───────────────────────────────────────┐ +// ▼ │ ▽ +// ┌──────────────────┐ 1-n ┌─────────────────┐ ┌──────────┐ +// │ Sample │ ──────▷ │ KeyValueAndUnit │ │ Link │ +// └──────────────────┘ └─────────────────┘ └──────────┘ +// │ △ △ +// │ n-1 │ │ 1-n +// ▽ │ │ +// ┌──────────────────┐ │ │ +// │ Stack │ │ │ +// └──────────────────┘ │ │ +// │ 1-n │ │ +// │ 1-n ┌────────────────┘ │ +// ▽ │ │ +// ┌──────────────────┐ n-1 ┌─────────────┐ +// │ Location │ ──────▷ │ Mapping │ +// └──────────────────┘ └─────────────┘ +// │ +// │ 1-n +// ▼ +// ┌──────────────────┐ +// │ Line │ +// └──────────────────┘ +// │ +// │ 1-1 +// ▽ +// ┌──────────────────┐ +// │ Function │ +// └──────────────────┘ +// + +// ProfilesDictionary represents the profiles data shared across the +// entire message being sent. 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. +// +// - A dictionary MUST have a zero value encoded as the first element. 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 dupes in a dictionary. The identity of dictionary +// items is based on their value, recursively as needed. If a particular +// implementation does emit duplicated items, it MUST NOT attempt to give them +// meaning based on the index or order. A profile processor may remove +// duplicate items 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. +// +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 always be zero value (Mapping{}) and present. + repeated Mapping mapping_table = 1; + + // Locations referenced by samples via Stack.location_indices. + // + // location_table[0] must always be zero value (Location{}) and present. + repeated Location location_table = 2; + + // Functions referenced by locations via Line.function_index. + // + // function_table[0] must always be zero value (Function{}) and present. + repeated Function function_table = 3; + + // Links referenced by samples via Sample.link_index. + // + // link_table[0] must always be zero value (Link{}) and present. + repeated Link link_table = 4; + + // A common table for strings referenced by various messages. + // + // string_table[0] must always be "" and present. + repeated string string_table = 5; + + // A common table for attributes referenced by the Profile, Sample, Mapping + // and Location messages below through attribute_indices field. Each entry is + // a key/value pair with an optional unit. Since this is a dictionary table, + // multiple entries with the same key may be present, unlike direct attribute + // tables like Resource.attributes. The referencing attribute_indices fields, + // though, do 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 always be zero value (KeyValueAndUnit{}) and present. + repeated KeyValueAndUnit attribute_table = 6; + + // Stacks referenced by samples via Sample.stack_index. + // + // stack_table[0] must always be 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. +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; + + // One instance of ProfilesDictionary + ProfilesDictionary dictionary = 2; +} + + +// A collection of ScopeProfiles from a Resource. +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 a 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 have their own schema_url field. + string schema_url = 3; +} + +// A collection of Profiles produced by an InstrumentationScope. +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 an 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. +// +// - 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. +// +// Note that whilst fields in this message retain the name and field id from pprof in most cases +// for ease of understanding data migration, it is not intended that pprof:Profile and +// OpenTelemetry:Profile encoding be wire compatible. +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) represented as nanoseconds past the epoch. + fixed64 time_unix_nano = 3; + // Duration of the profile, if a duration makes sense. + uint64 duration_nano = 4; + // The kind of events between sampled occurrences. + // e.g [ "cpu","cycles" ] or [ "heap","bytes" ] + ValueType period_type = 5; + // The number of events between sampled occurrences. + 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. Optional, but the + // format and the bytes must be set or unset together. + // + // 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 optionally provided when the conversion to the + // OLTP format was done from a different format with some loss of the fidelity + // and the receiver may want to store the original payload to allow future + // lossless export or reinterpretation. Some examples of the original format + // are JFR (Java Flight Recorder), pprof, Linux perf. + // + // Even when the original payload is in a format that is semantically close to + // OTLP, such as pprof, a conversion may still be lossy in some cases (e.g. if + // the pprof file contains custom extensions or conventions). + // + // The original payload can be large in size, so including the original + // payload should be configurable by the profiler or collector options. The + // default behavior should be to not include the original payload. + string original_payload_format = 9; + // The original payload bytes. See also original_payload_format. Optional, but + // format and the bytes must be set or unset together. + 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. +message Link { + // A unique identifier of a 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. +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 values or timestamps_unix_nano entry. 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. +// +// Examples of different ways of representing a sample with the total value of 10: +// +// Report of a stacktrace at 10 timestamps (consumers must assume the value is 1 for each point): +// values: [] +// timestamps_unix_nano: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +// +// Report of a stacktrace with an aggregated value without timestamps: +// values: [10] +// timestamps_unix_nano: [] +// +// Report of a stacktrace at 4 timestamps where each point records a specific value: +// values: [2, 2, 3, 3] +// timestamps_unix_nano: [1, 2, 3, 4] +message Sample { + // Reference to stack in ProfilesDictionary.stack_table. + int32 stack_index = 1; + // The type and unit of each value is defined by Profile.sample_type. + repeated int64 values = 2; + // References to attributes in ProfilesDictionary.attribute_table. [optional] + repeated int32 attribute_indices = 3; + + // Reference to link in ProfilesDictionary.link_table. [optional] + // It can be unset / set to 0 if no link exists, as link_table[0] is always a 'null' default value. + int32 link_index = 4; + + // Timestamps associated with Sample represented in nanoseconds. These + // timestamps should fall within the Profile's time range. + 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 +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 virtual + // abstractions 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. +message Stack { + // References to locations in ProfilesDictionary.location_table. + // The first location is the leaf frame. + repeated int32 location_indices = 1; +} + +// Describes function and line table debug information. +message Location { + // Reference to mapping in ProfilesDictionary.mapping_table. + // It can be unset / set to 0 if the mapping is unknown or not applicable for + // this profile type, as mapping_table[0] is always a 'null' default mapping. + 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 line indicates 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. +message Line { + // Reference to function in ProfilesDictionary.function_table. + int32 function_index = 1; + // Line number in source code. 0 means unset. + int64 line = 2; + // Column number in source code. 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. +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. 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 string table for keys and allows optional unit information. +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. + int32 unit_strindex = 3; +} diff --git a/modules/sync/opentelemetry/opentelemetry/cas/704c369fc3da0e58268eda980a6339ef2a6178a7db6f1c528c5cbd59e8652d3df5aeee57f163d8a8e15821a086b28b18bfd8ca715c7e7d8a8dde5b54a38f11d9 b/modules/sync/opentelemetry/opentelemetry/cas/704c369fc3da0e58268eda980a6339ef2a6178a7db6f1c528c5cbd59e8652d3df5aeee57f163d8a8e15821a086b28b18bfd8ca715c7e7d8a8dde5b54a38f11d9 new file mode 100644 index 00000000..23396620 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/704c369fc3da0e58268eda980a6339ef2a6178a7db6f1c528c5cbd59e8652d3df5aeee57f163d8a8e15821a086b28b18bfd8ca715c7e7d8a8dde5b54a38f11d9 @@ -0,0 +1,13 @@ +shake256:faedd41bb62749fa9e3e87f183fe58065f0d4ccf60e4d347727c04544ccdd08a43f1703d8f2cd31613fe1a767d63c33b280f34df99eda6ad2b25dfec4c4ead81 LICENSE +shake256:a5f1db61212d594f876df08d637ab2471c5ce8133de641eb5fcf1ad427c2648bf74657473b2691d1ab2bba6d24daf3f6d2e298921617800704d9f73d7f2928d3 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:095933bf1ec7011cd60e0f421c006d5f94707774188d2acd0f8979da5c66014c6d9c59749bc787642583ea5bd8ded31b203072ca9820aa53efc2811e3d6263c4 opentelemetry/proto/collector/profiles/v1development/profiles_service.proto +shake256:45484b5a296e7ce8b5420d7031909bf762f020daf6bff80b8eee794e2213b838f93ca3c920a529f4bb62889b49a734f35be032bce9caa51dd955b4f10ca52e51 opentelemetry/proto/collector/trace/v1/trace_service.proto +shake256:bef2ba517948380019de9b92b03bda823c053c1921d0d8cf23bc22ad47e7b938ce04625b705dd4b963b0d8796ef08c07b702f2fcce7179a0b6c183e7a6b4008f opentelemetry/proto/common/v1/common.proto +shake256:f4faf44cb51c74f31ec5656aaa435bbc809f86e81887b7a0b6034472d96cd49093b4f8d2daca99551cdd5ac7ba8ff7a50323c9e48f59aa1307003e3e2c50db80 opentelemetry/proto/logs/v1/logs.proto +shake256:971a5d39d2c3b851bef250244f991753d96e45c52fa53f4a874238098e5019535c66dab663aee020ff0e969d3cbc09c406335af81fd90d3f017dbbba809a2363 opentelemetry/proto/metrics/v1/metrics.proto +shake256:31f9ef66df2a709ffe84506dea5c5af1b02a524c2a8cd726e82cb5d76fe0b9421702e7f2434828aa4230d70745803cb0ca7c56592218db2facc5d9d08f321c9f 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/cas/8dee2b711709c2bb2b4aae0e587fd0e557c72d0ecdba6e4f4a463b87ca995fe91f6a0eb6d9246c01e2172ee33a911501f7aadb094fc5952020c4d1cb361fc7af b/modules/sync/opentelemetry/opentelemetry/cas/8dee2b711709c2bb2b4aae0e587fd0e557c72d0ecdba6e4f4a463b87ca995fe91f6a0eb6d9246c01e2172ee33a911501f7aadb094fc5952020c4d1cb361fc7af new file mode 100644 index 00000000..42c5913c --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/8dee2b711709c2bb2b4aae0e587fd0e557c72d0ecdba6e4f4a463b87ca995fe91f6a0eb6d9246c01e2172ee33a911501f7aadb094fc5952020c4d1cb361fc7af @@ -0,0 +1,45 @@ +// 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.resource.v1; + +import "opentelemetry/proto/common/v1/common.proto"; + +option csharp_namespace = "OpenTelemetry.Proto.Resource.V1"; +option java_multiple_files = true; +option java_package = "io.opentelemetry.proto.resource.v1"; +option java_outer_classname = "ResourceProto"; +option go_package = "go.opentelemetry.io/proto/otlp/resource/v1"; + +// Resource information. +message Resource { + // Set of attributes that describe the resource. + // 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; + + // The number of dropped attributes. If the value is 0, then + // no attributes were dropped. + uint32 dropped_attributes_count = 2; + + // Set of entities that participate in this Resource. + // + // Note: keys in the references MUST exist in attributes of this message. + // + // Status: [Development] + repeated opentelemetry.proto.common.v1.EntityRef entity_refs = 3; +} diff --git a/modules/sync/opentelemetry/opentelemetry/cas/971a5d39d2c3b851bef250244f991753d96e45c52fa53f4a874238098e5019535c66dab663aee020ff0e969d3cbc09c406335af81fd90d3f017dbbba809a2363 b/modules/sync/opentelemetry/opentelemetry/cas/971a5d39d2c3b851bef250244f991753d96e45c52fa53f4a874238098e5019535c66dab663aee020ff0e969d3cbc09c406335af81fd90d3f017dbbba809a2363 new file mode 100644 index 00000000..a6fab4ee --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/971a5d39d2c3b851bef250244f991753d96e45c52fa53f4a874238098e5019535c66dab663aee020ff0e969d3cbc09c406335af81fd90d3f017dbbba809a2363 @@ -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://unitsofmeasure.org/ucum.html. + 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/bef2ba517948380019de9b92b03bda823c053c1921d0d8cf23bc22ad47e7b938ce04625b705dd4b963b0d8796ef08c07b702f2fcce7179a0b6c183e7a6b4008f b/modules/sync/opentelemetry/opentelemetry/cas/bef2ba517948380019de9b92b03bda823c053c1921d0d8cf23bc22ad47e7b938ce04625b705dd4b963b0d8796ef08c07b702f2fcce7179a0b6c183e7a6b4008f new file mode 100644 index 00000000..7f9ffab3 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/bef2ba517948380019de9b92b03bda823c053c1921d0d8cf23bc22ad47e7b938ce04625b705dd4b963b0d8796ef08c07b702f2fcce7179a0b6c183e7a6b4008f @@ -0,0 +1,129 @@ +// 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; + } +} + +// 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. + string key = 1; + + // The value of the pair. + AnyValue value = 2; +} + +// 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/daf84eb52a7672684ee2e42f1d1c95689157356721f234a0dcf990ce62d138368a7968a03169551c154f3ca0ef3b94dea95f1b3ec07c7c4dfe74cf6e9ba99899 b/modules/sync/opentelemetry/opentelemetry/cas/daf84eb52a7672684ee2e42f1d1c95689157356721f234a0dcf990ce62d138368a7968a03169551c154f3ca0ef3b94dea95f1b3ec07c7c4dfe74cf6e9ba99899 new file mode 100644 index 00000000..8a992c14 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/daf84eb52a7672684ee2e42f1d1c95689157356721f234a0dcf990ce62d138368a7968a03169551c154f3ca0ef3b94dea95f1b3ec07c7c4dfe74cf6e9ba99899 @@ -0,0 +1,359 @@ +// 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.trace.v1; + +import "opentelemetry/proto/common/v1/common.proto"; +import "opentelemetry/proto/resource/v1/resource.proto"; + +option csharp_namespace = "OpenTelemetry.Proto.Trace.V1"; +option java_multiple_files = true; +option java_package = "io.opentelemetry.proto.trace.v1"; +option java_outer_classname = "TraceProto"; +option go_package = "go.opentelemetry.io/proto/otlp/trace/v1"; + +// TracesData represents the traces data that can be stored in a persistent storage, +// OR can be embedded by other protocols that transfer OTLP traces 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. +message TracesData { + // An array of ResourceSpans. + // 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 ResourceSpans resource_spans = 1; +} + +// A collection of ScopeSpans from a Resource. +message ResourceSpans { + reserved 1000; + + // The resource for the spans 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 ScopeSpans that originate from a resource. + repeated ScopeSpans scope_spans = 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_spans" field which have their own schema_url field. + string schema_url = 3; +} + +// A collection of Spans produced by an InstrumentationScope. +message ScopeSpans { + // The instrumentation scope information for the spans 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 Spans that originate from an instrumentation scope. + repeated Span spans = 2; + + // The Schema URL, if known. This is the identifier of the Schema that the span 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 spans and span + // events in the "spans" field. + string schema_url = 3; +} + +// A Span represents a single operation performed by a single component of the system. +// +// The next available field id is 17. +message Span { + // A unique identifier for a trace. All spans from the same trace share + // the same `trace_id`. The ID is a 16-byte array. An ID with all zeroes OR + // of length other than 16 bytes is considered invalid (empty string in OTLP/JSON + // is zero-length and thus is also invalid). + // + // This field is required. + bytes trace_id = 1; + + // A unique identifier for a span within a trace, assigned when the span + // is created. The ID is an 8-byte array. An ID with all zeroes OR of length + // other than 8 bytes is considered invalid (empty string in OTLP/JSON + // is zero-length and thus is also invalid). + // + // This field is required. + bytes span_id = 2; + + // trace_state conveys information about request position in multiple distributed tracing graphs. + // It is a trace_state in w3c-trace-context format: https://www.w3.org/TR/trace-context/#tracestate-header + // See also https://github.com/w3c/distributed-tracing for more details about this field. + string trace_state = 3; + + // The `span_id` of this span's parent span. If this is a root span, then this + // field must be empty. The ID is an 8-byte array. + bytes parent_span_id = 4; + + // Flags, a bit field. + // + // Bits 0-7 (8 least significant bits) are the trace flags as defined in W3C Trace + // Context specification. To read the 8-bit W3C trace flag, use + // `flags & SPAN_FLAGS_TRACE_FLAGS_MASK`. + // + // See https://www.w3.org/TR/trace-context-2/#trace-flags for the flag definitions. + // + // Bits 8 and 9 represent the 3 states of whether a span's parent + // is remote. The states are (unknown, is not remote, is remote). + // To read whether the value is known, use `(flags & SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK) != 0`. + // To read whether the span is remote, use `(flags & SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK) != 0`. + // + // When creating span messages, if the message is logically forwarded from another source + // with an equivalent flags fields (i.e., usually another OTLP span message), the field SHOULD + // be copied as-is. If creating from a source that does not have an equivalent flags field + // (such as a runtime representation of an OpenTelemetry span), the high 22 bits MUST + // be set to zero. + // Readers MUST NOT assume that bits 10-31 (22 most significant bits) will be zero. + // + // [Optional]. + fixed32 flags = 16; + + // A description of the span's operation. + // + // For example, the name can be a qualified method name or a file name + // and a line number where the operation is called. A best practice is to use + // the same display name at the same call point in an application. + // This makes it easier to correlate spans in different traces. + // + // This field is semantically required to be set to non-empty string. + // Empty value is equivalent to an unknown span name. + // + // This field is required. + string name = 5; + + // SpanKind is the type of span. Can be used to specify additional relationships between spans + // in addition to a parent/child relationship. + enum SpanKind { + // Unspecified. Do NOT use as default. + // Implementations MAY assume SpanKind to be INTERNAL when receiving UNSPECIFIED. + SPAN_KIND_UNSPECIFIED = 0; + + // Indicates that the span represents an internal operation within an application, + // as opposed to an operation happening at the boundaries. Default value. + SPAN_KIND_INTERNAL = 1; + + // Indicates that the span covers server-side handling of an RPC or other + // remote network request. + SPAN_KIND_SERVER = 2; + + // Indicates that the span describes a request to some remote service. + SPAN_KIND_CLIENT = 3; + + // Indicates that the span describes a producer sending a message to a broker. + // Unlike CLIENT and SERVER, there is often no direct critical path latency relationship + // between producer and consumer spans. A PRODUCER span ends when the message was accepted + // by the broker while the logical processing of the message might span a much longer time. + SPAN_KIND_PRODUCER = 4; + + // Indicates that the span describes consumer receiving a message from a broker. + // Like the PRODUCER kind, there is often no direct critical path latency relationship + // between producer and consumer spans. + SPAN_KIND_CONSUMER = 5; + } + + // Distinguishes between spans generated in a particular context. For example, + // two spans with the same name may be distinguished using `CLIENT` (caller) + // and `SERVER` (callee) to identify queueing latency associated with the span. + SpanKind kind = 6; + + // The start time of the span. On the client side, this is the time + // kept by the local machine where the span execution starts. On the server side, this + // is the time when the server's application handler starts running. + // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. + // + // This field is semantically required and it is expected that end_time >= start_time. + fixed64 start_time_unix_nano = 7; + + // The end time of the span. On the client side, this is the time + // kept by the local machine where the span execution ends. On the server side, this + // is the time when the server application handler stops running. + // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. + // + // This field is semantically required and it is expected that end_time >= start_time. + fixed64 end_time_unix_nano = 8; + + // A collection of key/value pairs. Note, global attributes + // like server name can be set using the resource API. 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" + // "/http/server_latency": 300 + // "example.com/myattribute": true + // "example.com/score": 10.239 + // + // 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; + + // 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 = 10; + + // Event is a time-stamped annotation of the span, consisting of user-supplied + // text description and key-value pairs. + message Event { + // The time the event occurred. + fixed64 time_unix_nano = 1; + + // The name of the event. + // This field is semantically required to be set to non-empty string. + string name = 2; + + // A collection of attribute key/value pairs on the event. + // 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 = 3; + + // The number of dropped attributes. If the value is 0, + // then no attributes were dropped. + uint32 dropped_attributes_count = 4; + } + + // A collection of Event items. + repeated Event events = 11; + + // The number of dropped events. If the value is 0, then no + // events were dropped. + uint32 dropped_events_count = 12; + + // A pointer from the current span to another span in the same trace or in a + // different trace. For example, this can be used in batching operations, + // where a single batch handler processes multiple requests from different + // traces or when the handler receives a request from a different project. + message Link { + // A unique identifier of a 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; + + // The trace_state associated with the link. + string trace_state = 3; + + // A collection of attribute key/value pairs on the link. + // 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 = 4; + + // The number of dropped attributes. If the value is 0, + // then no attributes were dropped. + uint32 dropped_attributes_count = 5; + + // Flags, a bit field. + // + // Bits 0-7 (8 least significant bits) are the trace flags as defined in W3C Trace + // Context specification. To read the 8-bit W3C trace flag, use + // `flags & SPAN_FLAGS_TRACE_FLAGS_MASK`. + // + // See https://www.w3.org/TR/trace-context-2/#trace-flags for the flag definitions. + // + // Bits 8 and 9 represent the 3 states of whether the link is remote. + // The states are (unknown, is not remote, is remote). + // To read whether the value is known, use `(flags & SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK) != 0`. + // To read whether the link is remote, use `(flags & SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK) != 0`. + // + // Readers MUST NOT assume that bits 10-31 (22 most significant bits) will be zero. + // When creating new spans, bits 10-31 (most-significant 22-bits) MUST be zero. + // + // [Optional]. + fixed32 flags = 6; + } + + // A collection of Links, which are references from this span to a span + // in the same or different trace. + repeated Link links = 13; + + // The number of dropped links after the maximum size was + // enforced. If this value is 0, then no links were dropped. + uint32 dropped_links_count = 14; + + // An optional final status for this span. Semantically when Status isn't set, it means + // span's status code is unset, i.e. assume STATUS_CODE_UNSET (code = 0). + Status status = 15; +} + +// The Status type defines a logical error model that is suitable for different +// programming environments, including REST APIs and RPC APIs. +message Status { + reserved 1; + + // A developer-facing human readable error message. + string message = 2; + + // For the semantics of status codes see + // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#set-status + enum StatusCode { + // The default status. + STATUS_CODE_UNSET = 0; + // The Span has been validated by an Application developer or Operator to + // have completed successfully. + STATUS_CODE_OK = 1; + // The Span contains an error. + STATUS_CODE_ERROR = 2; + }; + + // The status code. + StatusCode code = 3; +} + +// SpanFlags represents constants used to interpret the +// Span.flags field, which is protobuf 'fixed32' type and is to +// be used as bit-fields. Each non-zero value defined in this enum is +// a bit-mask. To extract the bit-field, for example, use an +// expression like: +// +// (span.flags & SPAN_FLAGS_TRACE_FLAGS_MASK) +// +// See https://www.w3.org/TR/trace-context-2/#trace-flags for the flag definitions. +// +// Note that Span flags were introduced in version 1.1 of the +// OpenTelemetry protocol. Older Span producers do not set this +// field, consequently consumers should not rely on the absence of a +// particular flag bit to indicate the presence of a particular feature. +enum SpanFlags { + // The zero value for the enum. Should not be used for comparisons. + // Instead use bitwise "and" with the appropriate mask as shown above. + SPAN_FLAGS_DO_NOT_USE = 0; + + // Bits 0-7 are used for trace flags. + SPAN_FLAGS_TRACE_FLAGS_MASK = 0x000000FF; + + // Bits 8 and 9 are used to indicate that the parent span or link span is remote. + // Bit 8 (`HAS_IS_REMOTE`) indicates whether the value is known. + // Bit 9 (`IS_REMOTE`) indicates whether the span or link is remote. + SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 0x00000100; + SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 0x00000200; + + // Bits 10-31 are reserved for future use. +} diff --git a/modules/sync/opentelemetry/opentelemetry/cas/f4faf44cb51c74f31ec5656aaa435bbc809f86e81887b7a0b6034472d96cd49093b4f8d2daca99551cdd5ac7ba8ff7a50323c9e48f59aa1307003e3e2c50db80 b/modules/sync/opentelemetry/opentelemetry/cas/f4faf44cb51c74f31ec5656aaa435bbc809f86e81887b7a0b6034472d96cd49093b4f8d2daca99551cdd5ac7ba8ff7a50323c9e48f59aa1307003e3e2c50db80 new file mode 100644 index 00000000..842c93c1 --- /dev/null +++ b/modules/sync/opentelemetry/opentelemetry/cas/f4faf44cb51c74f31ec5656aaa435bbc809f86e81887b7a0b6034472d96cd49093b4f8d2daca99551cdd5ac7ba8ff7a50323c9e48f59aa1307003e3e2c50db80 @@ -0,0 +1,227 @@ +// Copyright 2020, 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.logs.v1; + +import "opentelemetry/proto/common/v1/common.proto"; +import "opentelemetry/proto/resource/v1/resource.proto"; + +option csharp_namespace = "OpenTelemetry.Proto.Logs.V1"; +option java_multiple_files = true; +option java_package = "io.opentelemetry.proto.logs.v1"; +option java_outer_classname = "LogsProto"; +option go_package = "go.opentelemetry.io/proto/otlp/logs/v1"; + +// LogsData represents the logs data that can be stored in a persistent storage, +// OR can be embedded by other protocols that transfer OTLP logs 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. +message LogsData { + // An array of ResourceLogs. + // 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 ResourceLogs resource_logs = 1; +} + +// A collection of ScopeLogs from a Resource. +message ResourceLogs { + reserved 1000; + + // The resource for the logs in this message. + // If this field is not set then resource info is unknown. + opentelemetry.proto.resource.v1.Resource resource = 1; + + // A list of ScopeLogs that originate from a resource. + repeated ScopeLogs scope_logs = 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_logs" field which have their own schema_url field. + string schema_url = 3; +} + +// A collection of Logs produced by a Scope. +message ScopeLogs { + // The instrumentation scope information for the logs 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 log records. + repeated LogRecord log_records = 2; + + // The Schema URL, if known. This is the identifier of the Schema that the log 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 logs in the + // "log_records" field. + string schema_url = 3; +} + +// Possible values for LogRecord.SeverityNumber. +enum SeverityNumber { + // UNSPECIFIED is the default SeverityNumber, it MUST NOT be used. + SEVERITY_NUMBER_UNSPECIFIED = 0; + SEVERITY_NUMBER_TRACE = 1; + SEVERITY_NUMBER_TRACE2 = 2; + SEVERITY_NUMBER_TRACE3 = 3; + SEVERITY_NUMBER_TRACE4 = 4; + SEVERITY_NUMBER_DEBUG = 5; + SEVERITY_NUMBER_DEBUG2 = 6; + SEVERITY_NUMBER_DEBUG3 = 7; + SEVERITY_NUMBER_DEBUG4 = 8; + SEVERITY_NUMBER_INFO = 9; + SEVERITY_NUMBER_INFO2 = 10; + SEVERITY_NUMBER_INFO3 = 11; + SEVERITY_NUMBER_INFO4 = 12; + SEVERITY_NUMBER_WARN = 13; + SEVERITY_NUMBER_WARN2 = 14; + SEVERITY_NUMBER_WARN3 = 15; + SEVERITY_NUMBER_WARN4 = 16; + SEVERITY_NUMBER_ERROR = 17; + SEVERITY_NUMBER_ERROR2 = 18; + SEVERITY_NUMBER_ERROR3 = 19; + SEVERITY_NUMBER_ERROR4 = 20; + SEVERITY_NUMBER_FATAL = 21; + SEVERITY_NUMBER_FATAL2 = 22; + SEVERITY_NUMBER_FATAL3 = 23; + SEVERITY_NUMBER_FATAL4 = 24; +} + +// LogRecordFlags represents constants used to interpret the +// LogRecord.flags field, which is protobuf 'fixed32' type and is to +// be used as bit-fields. Each non-zero value defined in this enum is +// a bit-mask. To extract the bit-field, for example, use an +// expression like: +// +// (logRecord.flags & LOG_RECORD_FLAGS_TRACE_FLAGS_MASK) +// +enum LogRecordFlags { + // The zero value for the enum. Should not be used for comparisons. + // Instead use bitwise "and" with the appropriate mask as shown above. + LOG_RECORD_FLAGS_DO_NOT_USE = 0; + + // Bits 0-7 are used for trace flags. + LOG_RECORD_FLAGS_TRACE_FLAGS_MASK = 0x000000FF; + + // Bits 8-31 are reserved for future use. +} + +// A log record according to OpenTelemetry Log Data Model: +// https://github.com/open-telemetry/oteps/blob/main/text/logs/0097-log-data-model.md +message LogRecord { + reserved 4; + + // time_unix_nano is the time when the event occurred. + // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. + // Value of 0 indicates unknown or missing timestamp. + fixed64 time_unix_nano = 1; + + // Time when the event was observed by the collection system. + // For events that originate in OpenTelemetry (e.g. using OpenTelemetry Logging SDK) + // this timestamp is typically set at the generation time and is equal to Timestamp. + // For events originating externally and collected by OpenTelemetry (e.g. using + // Collector) this is the time when OpenTelemetry's code observed the event measured + // by the clock of the OpenTelemetry code. This field MUST be set once the event is + // observed by OpenTelemetry. + // + // For converting OpenTelemetry log data to formats that support only one timestamp or + // when receiving OpenTelemetry log data by recipients that support only one timestamp + // internally the following logic is recommended: + // - Use time_unix_nano if it is present, otherwise use observed_time_unix_nano. + // + // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. + // Value of 0 indicates unknown or missing timestamp. + fixed64 observed_time_unix_nano = 11; + + // Numerical value of the severity, normalized to values described in Log Data Model. + // [Optional]. + SeverityNumber severity_number = 2; + + // The severity text (also known as log level). The original string representation as + // it is known at the source. [Optional]. + string severity_text = 3; + + // A value containing the body of the log record. Can be for example a human-readable + // string message (including multi-line) describing the event in a free form or it can + // be a structured data composed of arrays and maps of other values. [Optional]. + opentelemetry.proto.common.v1.AnyValue body = 5; + + // Additional attributes that describe the specific event occurrence. [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 opentelemetry.proto.common.v1.KeyValue attributes = 6; + uint32 dropped_attributes_count = 7; + + // Flags, a bit field. 8 least significant bits are the trace flags as + // defined in W3C Trace Context specification. 24 most significant bits are reserved + // and must be set to 0. Readers must not assume that 24 most significant bits + // will be zero and must correctly mask the bits when reading 8-bit trace flag (use + // flags & LOG_RECORD_FLAGS_TRACE_FLAGS_MASK). [Optional]. + fixed32 flags = 8; + + // A unique identifier for a trace. All logs from the same trace share + // the same `trace_id`. The ID is a 16-byte array. An ID with all zeroes OR + // of length other than 16 bytes is considered invalid (empty string in OTLP/JSON + // is zero-length and thus is also invalid). + // + // This field is optional. + // + // The receivers SHOULD assume that the log record is not associated with a + // trace if any of the following is true: + // - the field is not present, + // - the field contains an invalid value. + bytes trace_id = 9; + + // A unique identifier for a span within a trace, assigned when the span + // is created. The ID is an 8-byte array. An ID with all zeroes OR of length + // other than 8 bytes is considered invalid (empty string in OTLP/JSON + // is zero-length and thus is also invalid). + // + // This field is optional. If the sender specifies a valid span_id then it SHOULD also + // specify a valid trace_id. + // + // The receivers SHOULD assume that the log record is not associated with a + // span if any of the following is true: + // - the field is not present, + // - the field contains an invalid value. + bytes span_id = 10; + + // A unique identifier of event category/type. + // All events with the same event_name are expected to conform to the same + // schema for both their attributes and their body. + // + // Recommended to be fully qualified and short (no longer than 256 characters). + // + // Presence of event_name on the log record identifies this record + // as an event. + // + // [Optional]. + string event_name = 12; +} diff --git a/modules/sync/opentelemetry/opentelemetry/state.json b/modules/sync/opentelemetry/opentelemetry/state.json index 83f47cbf..6345cf1e 100644 --- a/modules/sync/opentelemetry/opentelemetry/state.json +++ b/modules/sync/opentelemetry/opentelemetry/state.json @@ -27,6 +27,10 @@ { "name": "v1.8.0", "digest": "876c5eafb14069d6ee37de358b4913cc3b2f3bcd5948e4a7b7694d4e95b53a30816c6a488e9757e15e7f11bf13090195746f13015bd935224df711215dbf0152" + }, + { + "name": "v1.9.0", + "digest": "704c369fc3da0e58268eda980a6339ef2a6178a7db6f1c528c5cbd59e8652d3df5aeee57f163d8a8e15821a086b28b18bfd8ca715c7e7d8a8dde5b54a38f11d9" } ] } \ No newline at end of file diff --git a/modules/sync/state.json b/modules/sync/state.json index 0aee9080..29a39e87 100644 --- a/modules/sync/state.json +++ b/modules/sync/state.json @@ -18,7 +18,7 @@ }, { "module_name": "cncf/xds", - "latest_reference": "0feb69152e9f7e8a45c8a3cfe8c7dd93bca3512f" + "latest_reference": "5cf4b19495289a9e992ce5e2c3ffb08f2cf387be" }, { "module_name": "envoyproxy/envoy", @@ -38,7 +38,7 @@ }, { "module_name": "google/cel-spec", - "latest_reference": "v0.24.0" + "latest_reference": "v0.25.0" }, { "module_name": "googleapis/googleapis", @@ -66,7 +66,7 @@ }, { "module_name": "opentelemetry/opentelemetry", - "latest_reference": "v1.8.0" + "latest_reference": "v1.9.0" }, { "module_name": "prometheus/client-model",