From 61de3f77ff8e5e31d02d66f76dd90ecfcfad53ed Mon Sep 17 00:00:00 2001 From: Bogdan Drutu Date: Thu, 4 Aug 2022 15:35:37 -0700 Subject: [PATCH] Bump to opentelemetry proto 0.19.0 (#5823) Signed-off-by: Bogdan --- CHANGELOG.md | 2 + Makefile | 2 +- .../collector/logs/v1/logs_service.pb.go | 339 ++++- .../metrics/v1/metrics_service.pb.go | 339 ++++- .../collector/trace/v1/trace_config.pb.go | 1250 ----------------- .../collector/trace/v1/trace_service.pb.go | 338 ++++- .../data/protogen/common/v1/common.pb.go | 327 ++--- .../internal/data/protogen/logs/v1/logs.pb.go | 511 +------ .../data/protogen/metrics/v1/metrics.pb.go | 630 ++------- .../data/protogen/resource/v1/resource.pb.go | 9 +- .../data/protogen/trace/v1/trace.pb.go | 540 +------ proto_patch.sed | 3 - 12 files changed, 1315 insertions(+), 2975 deletions(-) delete mode 100644 pdata/internal/data/protogen/collector/trace/v1/trace_config.pb.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 4936ac646b3..bb6fe2c7295 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -37,6 +37,8 @@ ### 💡 Enhancements 💡 +- Bump to opentelemetry-proto v0.19.0. (#5823) + ### 🧰 Bug fixes 🧰 ## v0.57.2 Beta diff --git a/Makefile b/Makefile index c51e88be119..bff7c435ff2 100644 --- a/Makefile +++ b/Makefile @@ -236,7 +236,7 @@ gendependabot: $(eval SHELL:=/bin/bash) OPENTELEMETRY_PROTO_SRC_DIR=pdata/internal/opentelemetry-proto # The SHA matching the current version of the proto to use -OPENTELEMETRY_PROTO_VERSION=v0.18.0 +OPENTELEMETRY_PROTO_VERSION=v0.19.0 # Find all .proto files. OPENTELEMETRY_PROTO_FILES := $(subst $(OPENTELEMETRY_PROTO_SRC_DIR)/,,$(wildcard $(OPENTELEMETRY_PROTO_SRC_DIR)/opentelemetry/proto/*/v1/*.proto $(OPENTELEMETRY_PROTO_SRC_DIR)/opentelemetry/proto/collector/*/v1/*.proto)) diff --git a/pdata/internal/data/protogen/collector/logs/v1/logs_service.pb.go b/pdata/internal/data/protogen/collector/logs/v1/logs_service.pb.go index 54736710b1e..11c8e1aaf44 100644 --- a/pdata/internal/data/protogen/collector/logs/v1/logs_service.pb.go +++ b/pdata/internal/data/protogen/collector/logs/v1/logs_service.pb.go @@ -80,6 +80,22 @@ func (m *ExportLogsServiceRequest) GetResourceLogs() []*v1.ResourceLogs { } type ExportLogsServiceResponse struct { + // The details of a partially successful export request. + // + // If the request is only partially accepted + // (i.e. when the server accepts only parts of the data and rejects the rest) + // the server MUST initialize the `partial_success` field and MUST + // set the `rejected_` with the number of items it rejected. + // + // Servers MAY also make use of the `partial_success` field to convey + // warnings/suggestions to senders even when the request was fully accepted. + // In such cases, the `rejected_` MUST have a value of `0` and + // the `error_message` MUST be non-empty. + // + // A `partial_success` message with an empty value (rejected_ = 0 and + // `error_message` = "") is equivalent to it not being set/present. Senders + // SHOULD interpret it the same way as in the full success case. + PartialSuccess *ExportLogsPartialSuccess `protobuf:"bytes,1,opt,name=partial_success,json=partialSuccess,proto3" json:"partial_success,omitempty"` } func (m *ExportLogsServiceResponse) Reset() { *m = ExportLogsServiceResponse{} } @@ -115,9 +131,80 @@ func (m *ExportLogsServiceResponse) XXX_DiscardUnknown() { var xxx_messageInfo_ExportLogsServiceResponse proto.InternalMessageInfo +func (m *ExportLogsServiceResponse) GetPartialSuccess() *ExportLogsPartialSuccess { + if m != nil { + return m.PartialSuccess + } + return nil +} + +type ExportLogsPartialSuccess struct { + // The number of rejected log records. + // + // A `rejected_` field holding a `0` value indicates that the + // request was fully accepted. + RejectedLogRecords int64 `protobuf:"varint,1,opt,name=rejected_log_records,json=rejectedLogRecords,proto3" json:"rejected_log_records,omitempty"` + // A developer-facing human-readable message in English. It should be used + // either to explain why the server rejected parts of the data during a partial + // success or to convey warnings/suggestions during a full success. The message + // should offer guidance on how users can address such issues. + // + // error_message is an optional field. An error_message with an empty value + // is equivalent to it not being set. + ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"` +} + +func (m *ExportLogsPartialSuccess) Reset() { *m = ExportLogsPartialSuccess{} } +func (m *ExportLogsPartialSuccess) String() string { return proto.CompactTextString(m) } +func (*ExportLogsPartialSuccess) ProtoMessage() {} +func (*ExportLogsPartialSuccess) Descriptor() ([]byte, []int) { + return fileDescriptor_8e3bf87aaa43acd4, []int{2} +} +func (m *ExportLogsPartialSuccess) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExportLogsPartialSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExportLogsPartialSuccess.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ExportLogsPartialSuccess) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExportLogsPartialSuccess.Merge(m, src) +} +func (m *ExportLogsPartialSuccess) XXX_Size() int { + return m.Size() +} +func (m *ExportLogsPartialSuccess) XXX_DiscardUnknown() { + xxx_messageInfo_ExportLogsPartialSuccess.DiscardUnknown(m) +} + +var xxx_messageInfo_ExportLogsPartialSuccess proto.InternalMessageInfo + +func (m *ExportLogsPartialSuccess) GetRejectedLogRecords() int64 { + if m != nil { + return m.RejectedLogRecords + } + return 0 +} + +func (m *ExportLogsPartialSuccess) GetErrorMessage() string { + if m != nil { + return m.ErrorMessage + } + return "" +} + func init() { proto.RegisterType((*ExportLogsServiceRequest)(nil), "opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest") proto.RegisterType((*ExportLogsServiceResponse)(nil), "opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse") + proto.RegisterType((*ExportLogsPartialSuccess)(nil), "opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess") } func init() { @@ -125,26 +212,34 @@ func init() { } var fileDescriptor_8e3bf87aaa43acd4 = []byte{ - // 302 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0xc8, 0x2f, 0x48, 0xcd, - 0x2b, 0x49, 0xcd, 0x49, 0xcd, 0x4d, 0x2d, 0x29, 0xaa, 0xd4, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0xd7, - 0x4f, 0xce, 0xcf, 0xc9, 0x49, 0x4d, 0x2e, 0xc9, 0x2f, 0xd2, 0xcf, 0xc9, 0x4f, 0x2f, 0xd6, 0x2f, - 0x33, 0x04, 0xd3, 0xf1, 0xc5, 0xa9, 0x45, 0x65, 0x99, 0xc9, 0xa9, 0x7a, 0x60, 0x45, 0x42, 0xaa, - 0x28, 0x3a, 0x21, 0x82, 0x7a, 0x70, 0x9d, 0x7a, 0x20, 0x1d, 0x7a, 0x65, 0x86, 0x52, 0x22, 0xe9, - 0xf9, 0xe9, 0xf9, 0x10, 0x63, 0x41, 0x2c, 0x88, 0x3a, 0x29, 0x35, 0x6c, 0xd6, 0x22, 0x5b, 0x06, - 0x51, 0xa7, 0x94, 0xc5, 0x25, 0xe1, 0x5a, 0x51, 0x90, 0x5f, 0x54, 0xe2, 0x93, 0x9f, 0x5e, 0x1c, - 0x0c, 0xb1, 0x3f, 0x28, 0xb5, 0xb0, 0x34, 0xb5, 0xb8, 0x44, 0xc8, 0x8f, 0x8b, 0xb7, 0x28, 0xb5, - 0x38, 0xbf, 0xb4, 0x28, 0x39, 0x35, 0x1e, 0xa4, 0x45, 0x82, 0x51, 0x81, 0x59, 0x83, 0xdb, 0x48, - 0x53, 0x0f, 0x9b, 0xc3, 0xa0, 0xce, 0xd1, 0x0b, 0x82, 0xea, 0x00, 0x99, 0x17, 0xc4, 0x53, 0x84, - 0xc4, 0x53, 0x92, 0xe6, 0x92, 0xc4, 0x62, 0x57, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0xaa, 0xd1, 0x5c, - 0x46, 0x2e, 0x6e, 0x24, 0x71, 0xa1, 0x5e, 0x46, 0x2e, 0x36, 0x88, 0x6a, 0x21, 0x7b, 0x3d, 0xa2, - 0x42, 0x42, 0x0f, 0x97, 0x47, 0xa4, 0x1c, 0xc8, 0x37, 0x00, 0xe2, 0x3a, 0x25, 0x06, 0xa7, 0x25, - 0x8c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, - 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0xc0, 0xa5, 0x91, 0x99, 0x4f, 0x9c, - 0x05, 0x4e, 0x02, 0x48, 0x66, 0x07, 0x80, 0xd4, 0x04, 0x30, 0x46, 0xf9, 0xa4, 0xa3, 0xeb, 0xce, - 0x44, 0x4e, 0x20, 0x05, 0x29, 0x89, 0x25, 0x89, 0xfa, 0x99, 0x79, 0x25, 0xa9, 0x45, 0x79, 0x89, - 0x39, 0xfa, 0x60, 0x1e, 0xd8, 0xf8, 0xf4, 0xd4, 0x3c, 0xcc, 0x74, 0x94, 0xc4, 0x06, 0x96, 0x33, - 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x5e, 0x56, 0x81, 0x5e, 0x77, 0x02, 0x00, 0x00, + // 425 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0xc1, 0x6e, 0xd3, 0x40, + 0x10, 0x86, 0xb3, 0xad, 0x54, 0x89, 0x4d, 0x0b, 0x68, 0xd5, 0x43, 0xc8, 0xc1, 0xaa, 0x8c, 0x8a, + 0xcc, 0x65, 0x4d, 0xc2, 0x85, 0x1b, 0xa8, 0x88, 0x5b, 0x80, 0xc8, 0x45, 0x1c, 0xb8, 0x58, 0x66, + 0x33, 0x5a, 0x5c, 0xb9, 0x9e, 0xed, 0xec, 0x26, 0x82, 0x07, 0xe0, 0x88, 0xc4, 0x0b, 0xf0, 0x02, + 0x3c, 0x09, 0x07, 0x0e, 0x3d, 0x72, 0x44, 0xc9, 0x8b, 0xa0, 0xf5, 0x96, 0x60, 0x43, 0x0e, 0xa1, + 0xa7, 0x64, 0x66, 0xe7, 0xff, 0xfe, 0x7f, 0xd6, 0x36, 0x7f, 0x84, 0x06, 0x6a, 0x07, 0x15, 0x9c, + 0x83, 0xa3, 0x0f, 0xa9, 0x21, 0x74, 0x98, 0x2a, 0xac, 0x2a, 0x50, 0x0e, 0x29, 0xad, 0x50, 0xdb, + 0x74, 0x31, 0x6a, 0x7e, 0x73, 0x0b, 0xb4, 0x28, 0x15, 0xc8, 0x66, 0x48, 0x1c, 0x77, 0x94, 0xa1, + 0x29, 0xd7, 0x4a, 0xe9, 0x15, 0x72, 0x31, 0x1a, 0x1e, 0x6a, 0xd4, 0x18, 0xb0, 0xfe, 0x5f, 0x98, + 0x1b, 0xde, 0xdb, 0x64, 0xdb, 0x36, 0x0b, 0x73, 0xf1, 0x19, 0x1f, 0x3c, 0x7b, 0x6f, 0x90, 0xdc, + 0x04, 0xb5, 0x3d, 0x0d, 0xfe, 0x19, 0x5c, 0xcc, 0xc1, 0x3a, 0xf1, 0x82, 0x1f, 0x10, 0x58, 0x9c, + 0x93, 0x82, 0xdc, 0x4b, 0x06, 0xec, 0x68, 0x37, 0xe9, 0x8f, 0xef, 0xcb, 0x4d, 0xc1, 0xae, 0xe2, + 0xc8, 0xec, 0x4a, 0xe1, 0x79, 0xd9, 0x3e, 0xb5, 0xaa, 0xf8, 0x23, 0xe3, 0x77, 0x36, 0x98, 0x59, + 0x83, 0xb5, 0x05, 0xf1, 0x8e, 0xdf, 0x32, 0x05, 0xb9, 0xb2, 0xa8, 0x72, 0x3b, 0x57, 0x0a, 0xac, + 0xf7, 0x63, 0x49, 0x7f, 0xfc, 0x58, 0x6e, 0x75, 0x11, 0xf2, 0x0f, 0x7a, 0x1a, 0x38, 0xa7, 0x01, + 0x93, 0xdd, 0x34, 0x9d, 0x3a, 0xbe, 0x68, 0xef, 0xdc, 0x9d, 0x15, 0x0f, 0xf8, 0x21, 0xc1, 0x19, + 0x28, 0x07, 0x33, 0xbf, 0x73, 0x4e, 0xa0, 0x90, 0x66, 0x21, 0xca, 0x6e, 0x26, 0x7e, 0x9f, 0x4d, + 0x50, 0x67, 0xe1, 0x44, 0xdc, 0xe5, 0x07, 0x40, 0x84, 0x94, 0x9f, 0x83, 0xb5, 0x85, 0x86, 0xc1, + 0xce, 0x11, 0x4b, 0x6e, 0x64, 0xfb, 0x4d, 0xf3, 0x79, 0xe8, 0x8d, 0xbf, 0x30, 0xde, 0x6f, 0x2d, + 0x2d, 0x3e, 0x31, 0xbe, 0x17, 0x32, 0x88, 0xff, 0x5f, 0xaf, 0xfb, 0x98, 0x86, 0x4f, 0xae, 0x0f, + 0x08, 0x57, 0x1f, 0xf7, 0x4e, 0xbe, 0xb3, 0x6f, 0xcb, 0x88, 0x5d, 0x2e, 0x23, 0xf6, 0x73, 0x19, + 0xb1, 0xcf, 0xab, 0xa8, 0x77, 0xb9, 0x8a, 0x7a, 0x3f, 0x56, 0x51, 0x8f, 0x27, 0x25, 0x6e, 0x67, + 0x70, 0x72, 0xbb, 0xc5, 0x9e, 0xfa, 0x99, 0x29, 0x7b, 0x33, 0xd1, 0x7f, 0xab, 0xcb, 0xf6, 0xeb, + 0x6f, 0x66, 0x85, 0x2b, 0xd2, 0xb2, 0x76, 0x40, 0x75, 0x51, 0xa5, 0x4d, 0xd5, 0xe0, 0x35, 0xd4, + 0xff, 0x7e, 0x25, 0x5f, 0x77, 0x8e, 0x5f, 0x1a, 0xa8, 0x5f, 0xad, 0x59, 0x8d, 0x8b, 0x7c, 0xba, + 0x4e, 0xe2, 0x03, 0xc8, 0xd7, 0xa3, 0xb7, 0x7b, 0x0d, 0xe3, 0xe1, 0xaf, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xd0, 0x92, 0x26, 0x98, 0x7d, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -288,6 +383,53 @@ func (m *ExportLogsServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, erro _ = i var l int _ = l + if m.PartialSuccess != nil { + { + size, err := m.PartialSuccess.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLogsService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExportLogsPartialSuccess) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExportLogsPartialSuccess) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExportLogsPartialSuccess) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ErrorMessage) > 0 { + i -= len(m.ErrorMessage) + copy(dAtA[i:], m.ErrorMessage) + i = encodeVarintLogsService(dAtA, i, uint64(len(m.ErrorMessage))) + i-- + dAtA[i] = 0x12 + } + if m.RejectedLogRecords != 0 { + i = encodeVarintLogsService(dAtA, i, uint64(m.RejectedLogRecords)) + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } @@ -323,6 +465,26 @@ func (m *ExportLogsServiceResponse) Size() (n int) { } var l int _ = l + if m.PartialSuccess != nil { + l = m.PartialSuccess.Size() + n += 1 + l + sovLogsService(uint64(l)) + } + return n +} + +func (m *ExportLogsPartialSuccess) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RejectedLogRecords != 0 { + n += 1 + sovLogsService(uint64(m.RejectedLogRecords)) + } + l = len(m.ErrorMessage) + if l > 0 { + n += 1 + l + sovLogsService(uint64(l)) + } return n } @@ -445,6 +607,143 @@ func (m *ExportLogsServiceResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: ExportLogsServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PartialSuccess", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLogsService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLogsService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLogsService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PartialSuccess == nil { + m.PartialSuccess = &ExportLogsPartialSuccess{} + } + if err := m.PartialSuccess.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLogsService(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLogsService + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExportLogsPartialSuccess) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLogsService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExportLogsPartialSuccess: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExportLogsPartialSuccess: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RejectedLogRecords", wireType) + } + m.RejectedLogRecords = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLogsService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RejectedLogRecords |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ErrorMessage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLogsService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthLogsService + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLogsService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ErrorMessage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLogsService(dAtA[iNdEx:]) diff --git a/pdata/internal/data/protogen/collector/metrics/v1/metrics_service.pb.go b/pdata/internal/data/protogen/collector/metrics/v1/metrics_service.pb.go index e0657f4e5b4..1f90729a70f 100644 --- a/pdata/internal/data/protogen/collector/metrics/v1/metrics_service.pb.go +++ b/pdata/internal/data/protogen/collector/metrics/v1/metrics_service.pb.go @@ -80,6 +80,22 @@ func (m *ExportMetricsServiceRequest) GetResourceMetrics() []*v1.ResourceMetrics } type ExportMetricsServiceResponse struct { + // The details of a partially successful export request. + // + // If the request is only partially accepted + // (i.e. when the server accepts only parts of the data and rejects the rest) + // the server MUST initialize the `partial_success` field and MUST + // set the `rejected_` with the number of items it rejected. + // + // Servers MAY also make use of the `partial_success` field to convey + // warnings/suggestions to senders even when the request was fully accepted. + // In such cases, the `rejected_` MUST have a value of `0` and + // the `error_message` MUST be non-empty. + // + // A `partial_success` message with an empty value (rejected_ = 0 and + // `error_message` = "") is equivalent to it not being set/present. Senders + // SHOULD interpret it the same way as in the full success case. + PartialSuccess *ExportMetricsPartialSuccess `protobuf:"bytes,1,opt,name=partial_success,json=partialSuccess,proto3" json:"partial_success,omitempty"` } func (m *ExportMetricsServiceResponse) Reset() { *m = ExportMetricsServiceResponse{} } @@ -115,9 +131,80 @@ func (m *ExportMetricsServiceResponse) XXX_DiscardUnknown() { var xxx_messageInfo_ExportMetricsServiceResponse proto.InternalMessageInfo +func (m *ExportMetricsServiceResponse) GetPartialSuccess() *ExportMetricsPartialSuccess { + if m != nil { + return m.PartialSuccess + } + return nil +} + +type ExportMetricsPartialSuccess struct { + // The number of rejected data points. + // + // A `rejected_` field holding a `0` value indicates that the + // request was fully accepted. + RejectedDataPoints int64 `protobuf:"varint,1,opt,name=rejected_data_points,json=rejectedDataPoints,proto3" json:"rejected_data_points,omitempty"` + // A developer-facing human-readable message in English. It should be used + // either to explain why the server rejected parts of the data during a partial + // success or to convey warnings/suggestions during a full success. The message + // should offer guidance on how users can address such issues. + // + // error_message is an optional field. An error_message with an empty value + // is equivalent to it not being set. + ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"` +} + +func (m *ExportMetricsPartialSuccess) Reset() { *m = ExportMetricsPartialSuccess{} } +func (m *ExportMetricsPartialSuccess) String() string { return proto.CompactTextString(m) } +func (*ExportMetricsPartialSuccess) ProtoMessage() {} +func (*ExportMetricsPartialSuccess) Descriptor() ([]byte, []int) { + return fileDescriptor_75fb6015e6e64798, []int{2} +} +func (m *ExportMetricsPartialSuccess) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExportMetricsPartialSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExportMetricsPartialSuccess.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ExportMetricsPartialSuccess) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExportMetricsPartialSuccess.Merge(m, src) +} +func (m *ExportMetricsPartialSuccess) XXX_Size() int { + return m.Size() +} +func (m *ExportMetricsPartialSuccess) XXX_DiscardUnknown() { + xxx_messageInfo_ExportMetricsPartialSuccess.DiscardUnknown(m) +} + +var xxx_messageInfo_ExportMetricsPartialSuccess proto.InternalMessageInfo + +func (m *ExportMetricsPartialSuccess) GetRejectedDataPoints() int64 { + if m != nil { + return m.RejectedDataPoints + } + return 0 +} + +func (m *ExportMetricsPartialSuccess) GetErrorMessage() string { + if m != nil { + return m.ErrorMessage + } + return "" +} + func init() { proto.RegisterType((*ExportMetricsServiceRequest)(nil), "opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest") proto.RegisterType((*ExportMetricsServiceResponse)(nil), "opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse") + proto.RegisterType((*ExportMetricsPartialSuccess)(nil), "opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess") } func init() { @@ -125,26 +212,34 @@ func init() { } var fileDescriptor_75fb6015e6e64798 = []byte{ - // 303 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0xcb, 0x2f, 0x48, 0xcd, - 0x2b, 0x49, 0xcd, 0x49, 0xcd, 0x4d, 0x2d, 0x29, 0xaa, 0xd4, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0xd7, - 0x4f, 0xce, 0xcf, 0xc9, 0x49, 0x4d, 0x2e, 0xc9, 0x2f, 0xd2, 0x07, 0x89, 0x66, 0x26, 0x17, 0xeb, - 0x97, 0x19, 0xc2, 0x98, 0xf1, 0xc5, 0xa9, 0x45, 0x65, 0x99, 0xc9, 0xa9, 0x7a, 0x60, 0xa5, 0x42, - 0x1a, 0x28, 0xfa, 0x21, 0x82, 0x7a, 0x70, 0xfd, 0x7a, 0x50, 0x4d, 0x7a, 0x65, 0x86, 0x52, 0x22, - 0xe9, 0xf9, 0xe9, 0xf9, 0x10, 0xf3, 0x41, 0x2c, 0x88, 0x52, 0x29, 0x1d, 0x6c, 0xf6, 0x63, 0xda, - 0x0a, 0x51, 0xad, 0x54, 0xc9, 0x25, 0xed, 0x5a, 0x51, 0x90, 0x5f, 0x54, 0xe2, 0x0b, 0x11, 0x0e, - 0x86, 0xb8, 0x25, 0x28, 0xb5, 0xb0, 0x34, 0xb5, 0xb8, 0x44, 0x28, 0x8a, 0x4b, 0xa0, 0x28, 0xb5, - 0x38, 0xbf, 0xb4, 0x28, 0x39, 0x35, 0x1e, 0xaa, 0x51, 0x82, 0x51, 0x81, 0x59, 0x83, 0xdb, 0x48, - 0x5f, 0x0f, 0x9b, 0x3b, 0x11, 0xae, 0xd3, 0x0b, 0x82, 0xea, 0x83, 0x1a, 0x1c, 0xc4, 0x5f, 0x84, - 0x2a, 0xa0, 0x24, 0xc7, 0x25, 0x83, 0xdd, 0xea, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0xa3, 0x35, - 0x8c, 0x5c, 0x7c, 0xa8, 0x52, 0x42, 0x33, 0x19, 0xb9, 0xd8, 0x20, 0x7a, 0x84, 0x5c, 0xf5, 0x88, - 0x0d, 0x27, 0x3d, 0x3c, 0x1e, 0x94, 0x72, 0xa3, 0xd4, 0x18, 0x88, 0x63, 0x95, 0x18, 0x9c, 0xd6, - 0x32, 0x9e, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, - 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x03, 0x97, 0x76, 0x66, 0x3e, 0xd1, - 0xd6, 0x38, 0x09, 0xa3, 0xda, 0x10, 0x00, 0x52, 0x19, 0xc0, 0x18, 0xe5, 0x9f, 0x8e, 0x6e, 0x46, - 0x26, 0x72, 0xb2, 0x2a, 0x48, 0x49, 0x2c, 0x49, 0xd4, 0xcf, 0xcc, 0x2b, 0x49, 0x2d, 0xca, 0x4b, - 0xcc, 0xd1, 0x07, 0xf3, 0xc0, 0x96, 0xa4, 0xa7, 0xe6, 0x61, 0x4d, 0x7d, 0x49, 0x6c, 0x60, 0x69, - 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa1, 0x13, 0x8e, 0x3e, 0xb0, 0x02, 0x00, 0x00, + // 419 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x53, 0xbf, 0x8e, 0xd3, 0x30, + 0x18, 0x8f, 0xef, 0xa4, 0x93, 0xf0, 0xc1, 0x1d, 0x32, 0x37, 0x9c, 0x0a, 0x8a, 0x4e, 0x61, 0x89, + 0x04, 0x72, 0x68, 0xd9, 0x19, 0x0e, 0x8e, 0xed, 0xd4, 0x28, 0x45, 0x0c, 0x5d, 0x22, 0xe3, 0x7e, + 0x8a, 0x82, 0x52, 0xdb, 0xd8, 0x6e, 0x45, 0x5f, 0x02, 0xb1, 0xf2, 0x0a, 0x88, 0x07, 0x61, 0xec, + 0xd8, 0x11, 0xb5, 0x2f, 0x82, 0x12, 0xa7, 0x05, 0x97, 0x0c, 0x15, 0xb7, 0xd9, 0x3f, 0xff, 0xfe, + 0xf9, 0xb3, 0x8c, 0x5f, 0x49, 0x05, 0xc2, 0x42, 0x05, 0x53, 0xb0, 0x7a, 0x91, 0x28, 0x2d, 0xad, + 0x4c, 0xb8, 0xac, 0x2a, 0xe0, 0x56, 0xea, 0xa4, 0x46, 0x4b, 0x6e, 0x92, 0x79, 0x7f, 0xbb, 0xcc, + 0x0d, 0xe8, 0x79, 0xc9, 0x81, 0x36, 0x54, 0x12, 0x7b, 0x7a, 0x07, 0xd2, 0x9d, 0x9e, 0xb6, 0x22, + 0x3a, 0xef, 0xf7, 0x2e, 0x0a, 0x59, 0x48, 0xe7, 0x5f, 0xaf, 0x1c, 0xb5, 0xf7, 0xbc, 0x2b, 0xff, + 0xdf, 0x54, 0xc7, 0x8e, 0x16, 0xf8, 0xf1, 0xcd, 0x67, 0x25, 0xb5, 0xbd, 0x75, 0xf0, 0xc8, 0x75, + 0xc9, 0xe0, 0xd3, 0x0c, 0x8c, 0x25, 0x63, 0xfc, 0x50, 0x83, 0x91, 0x33, 0xcd, 0x21, 0x6f, 0x85, + 0x97, 0xe8, 0xea, 0x38, 0x3e, 0x1d, 0x24, 0xb4, 0xab, 0xe7, 0x9f, 0x76, 0x34, 0x6b, 0x75, 0xad, + 0x71, 0x76, 0xae, 0x7d, 0x20, 0xfa, 0x82, 0xf0, 0x93, 0xee, 0x6c, 0xa3, 0xa4, 0x30, 0x40, 0x04, + 0x3e, 0x57, 0x4c, 0xdb, 0x92, 0x55, 0xb9, 0x99, 0x71, 0x0e, 0xa6, 0xce, 0x46, 0xf1, 0xe9, 0xe0, + 0x86, 0x1e, 0x3a, 0x23, 0xea, 0x05, 0xa4, 0xce, 0x6d, 0xe4, 0xcc, 0xb2, 0x33, 0xe5, 0xed, 0x23, + 0xbb, 0x37, 0x0b, 0x9f, 0x4e, 0x5e, 0xe0, 0x0b, 0x0d, 0x1f, 0x81, 0x5b, 0x98, 0xe4, 0x13, 0x66, + 0x59, 0xae, 0x64, 0x29, 0xac, 0xeb, 0x74, 0x9c, 0x91, 0xed, 0xd9, 0x1b, 0x66, 0x59, 0xda, 0x9c, + 0x90, 0xa7, 0xf8, 0x01, 0x68, 0x2d, 0x75, 0x3e, 0x05, 0x63, 0x58, 0x01, 0x97, 0x47, 0x57, 0x28, + 0xbe, 0x97, 0xdd, 0x6f, 0xc0, 0x5b, 0x87, 0x0d, 0x7e, 0x20, 0x7c, 0xe6, 0x0f, 0x80, 0x7c, 0x43, + 0xf8, 0xc4, 0x35, 0x21, 0xff, 0x7b, 0x55, 0xff, 0x1d, 0x7b, 0x6f, 0xef, 0x6a, 0xe3, 0x9e, 0x24, + 0x0a, 0xae, 0x57, 0xe8, 0xe7, 0x3a, 0x44, 0xcb, 0x75, 0x88, 0x7e, 0xad, 0x43, 0xf4, 0x75, 0x13, + 0x06, 0xcb, 0x4d, 0x18, 0xac, 0x36, 0x61, 0x80, 0x9f, 0x95, 0xf2, 0xe0, 0x98, 0xeb, 0x47, 0x7e, + 0x42, 0x5a, 0x33, 0x53, 0x34, 0x1e, 0x16, 0xfb, 0x1e, 0xe5, 0xdf, 0xbf, 0x47, 0xd5, 0x83, 0x4f, + 0x4a, 0x61, 0x41, 0x0b, 0x56, 0x25, 0xcd, 0xae, 0x09, 0x29, 0x40, 0x74, 0x7e, 0xb2, 0xef, 0x47, + 0xf1, 0x50, 0x81, 0x78, 0xb7, 0xb3, 0x6b, 0x82, 0xe8, 0xeb, 0x5d, 0xa5, 0xb6, 0x06, 0x7d, 0xdf, + 0xff, 0x70, 0xd2, 0x38, 0xbd, 0xfc, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xc7, 0x82, 0x2e, 0x21, 0xc2, + 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -288,6 +383,53 @@ func (m *ExportMetricsServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, e _ = i var l int _ = l + if m.PartialSuccess != nil { + { + size, err := m.PartialSuccess.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintMetricsService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExportMetricsPartialSuccess) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExportMetricsPartialSuccess) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExportMetricsPartialSuccess) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ErrorMessage) > 0 { + i -= len(m.ErrorMessage) + copy(dAtA[i:], m.ErrorMessage) + i = encodeVarintMetricsService(dAtA, i, uint64(len(m.ErrorMessage))) + i-- + dAtA[i] = 0x12 + } + if m.RejectedDataPoints != 0 { + i = encodeVarintMetricsService(dAtA, i, uint64(m.RejectedDataPoints)) + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } @@ -323,6 +465,26 @@ func (m *ExportMetricsServiceResponse) Size() (n int) { } var l int _ = l + if m.PartialSuccess != nil { + l = m.PartialSuccess.Size() + n += 1 + l + sovMetricsService(uint64(l)) + } + return n +} + +func (m *ExportMetricsPartialSuccess) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RejectedDataPoints != 0 { + n += 1 + sovMetricsService(uint64(m.RejectedDataPoints)) + } + l = len(m.ErrorMessage) + if l > 0 { + n += 1 + l + sovMetricsService(uint64(l)) + } return n } @@ -445,6 +607,143 @@ func (m *ExportMetricsServiceResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: ExportMetricsServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PartialSuccess", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMetricsService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMetricsService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthMetricsService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PartialSuccess == nil { + m.PartialSuccess = &ExportMetricsPartialSuccess{} + } + if err := m.PartialSuccess.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMetricsService(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthMetricsService + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExportMetricsPartialSuccess) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMetricsService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExportMetricsPartialSuccess: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExportMetricsPartialSuccess: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RejectedDataPoints", wireType) + } + m.RejectedDataPoints = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMetricsService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RejectedDataPoints |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ErrorMessage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMetricsService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthMetricsService + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMetricsService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ErrorMessage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMetricsService(dAtA[iNdEx:]) diff --git a/pdata/internal/data/protogen/collector/trace/v1/trace_config.pb.go b/pdata/internal/data/protogen/collector/trace/v1/trace_config.pb.go deleted file mode 100644 index 363f3c13fef..00000000000 --- a/pdata/internal/data/protogen/collector/trace/v1/trace_config.pb.go +++ /dev/null @@ -1,1250 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: opentelemetry/proto/trace/v1/trace_config.proto - -package v1 - -import ( - encoding_binary "encoding/binary" - fmt "fmt" - io "io" - math "math" - math_bits "math/bits" - - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -// How spans should be sampled: -// - Always off -// - Always on -// - Always follow the parent Span's decision (off if no parent). -type ConstantSampler_ConstantDecision int32 - -const ( - ConstantSampler_ALWAYS_OFF ConstantSampler_ConstantDecision = 0 - ConstantSampler_ALWAYS_ON ConstantSampler_ConstantDecision = 1 - ConstantSampler_ALWAYS_PARENT ConstantSampler_ConstantDecision = 2 -) - -var ConstantSampler_ConstantDecision_name = map[int32]string{ - 0: "ALWAYS_OFF", - 1: "ALWAYS_ON", - 2: "ALWAYS_PARENT", -} - -var ConstantSampler_ConstantDecision_value = map[string]int32{ - "ALWAYS_OFF": 0, - "ALWAYS_ON": 1, - "ALWAYS_PARENT": 2, -} - -func (x ConstantSampler_ConstantDecision) String() string { - return proto.EnumName(ConstantSampler_ConstantDecision_name, int32(x)) -} - -func (ConstantSampler_ConstantDecision) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_5936aa8fa6443e6f, []int{1, 0} -} - -// Global configuration of the trace service. All fields must be specified, or -// the default (zero) values will be used for each type. -type TraceConfig struct { - // The global default sampler used to make decisions on span sampling. - // - // Types that are valid to be assigned to Sampler: - // *TraceConfig_ConstantSampler - // *TraceConfig_TraceIdRatioBased - // *TraceConfig_RateLimitingSampler - Sampler isTraceConfig_Sampler `protobuf_oneof:"sampler"` - // The global default max number of attributes per span. - MaxNumberOfAttributes int64 `protobuf:"varint,4,opt,name=max_number_of_attributes,json=maxNumberOfAttributes,proto3" json:"max_number_of_attributes,omitempty"` - // The global default max number of annotation events per span. - MaxNumberOfTimedEvents int64 `protobuf:"varint,5,opt,name=max_number_of_timed_events,json=maxNumberOfTimedEvents,proto3" json:"max_number_of_timed_events,omitempty"` - // The global default max number of attributes per timed event. - MaxNumberOfAttributesPerTimedEvent int64 `protobuf:"varint,6,opt,name=max_number_of_attributes_per_timed_event,json=maxNumberOfAttributesPerTimedEvent,proto3" json:"max_number_of_attributes_per_timed_event,omitempty"` - // The global default max number of link entries per span. - MaxNumberOfLinks int64 `protobuf:"varint,7,opt,name=max_number_of_links,json=maxNumberOfLinks,proto3" json:"max_number_of_links,omitempty"` - // The global default max number of attributes per span. - MaxNumberOfAttributesPerLink int64 `protobuf:"varint,8,opt,name=max_number_of_attributes_per_link,json=maxNumberOfAttributesPerLink,proto3" json:"max_number_of_attributes_per_link,omitempty"` -} - -func (m *TraceConfig) Reset() { *m = TraceConfig{} } -func (m *TraceConfig) String() string { return proto.CompactTextString(m) } -func (*TraceConfig) ProtoMessage() {} -func (*TraceConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_5936aa8fa6443e6f, []int{0} -} -func (m *TraceConfig) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *TraceConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_TraceConfig.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *TraceConfig) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceConfig.Merge(m, src) -} -func (m *TraceConfig) XXX_Size() int { - return m.Size() -} -func (m *TraceConfig) XXX_DiscardUnknown() { - xxx_messageInfo_TraceConfig.DiscardUnknown(m) -} - -var xxx_messageInfo_TraceConfig proto.InternalMessageInfo - -type isTraceConfig_Sampler interface { - isTraceConfig_Sampler() - MarshalTo([]byte) (int, error) - Size() int -} - -type TraceConfig_ConstantSampler struct { - ConstantSampler *ConstantSampler `protobuf:"bytes,1,opt,name=constant_sampler,json=constantSampler,proto3,oneof" json:"constant_sampler,omitempty"` -} -type TraceConfig_TraceIdRatioBased struct { - TraceIdRatioBased *TraceIdRatioBased `protobuf:"bytes,2,opt,name=trace_id_ratio_based,json=traceIdRatioBased,proto3,oneof" json:"trace_id_ratio_based,omitempty"` -} -type TraceConfig_RateLimitingSampler struct { - RateLimitingSampler *RateLimitingSampler `protobuf:"bytes,3,opt,name=rate_limiting_sampler,json=rateLimitingSampler,proto3,oneof" json:"rate_limiting_sampler,omitempty"` -} - -func (*TraceConfig_ConstantSampler) isTraceConfig_Sampler() {} -func (*TraceConfig_TraceIdRatioBased) isTraceConfig_Sampler() {} -func (*TraceConfig_RateLimitingSampler) isTraceConfig_Sampler() {} - -func (m *TraceConfig) GetSampler() isTraceConfig_Sampler { - if m != nil { - return m.Sampler - } - return nil -} - -func (m *TraceConfig) GetConstantSampler() *ConstantSampler { - if x, ok := m.GetSampler().(*TraceConfig_ConstantSampler); ok { - return x.ConstantSampler - } - return nil -} - -func (m *TraceConfig) GetTraceIdRatioBased() *TraceIdRatioBased { - if x, ok := m.GetSampler().(*TraceConfig_TraceIdRatioBased); ok { - return x.TraceIdRatioBased - } - return nil -} - -func (m *TraceConfig) GetRateLimitingSampler() *RateLimitingSampler { - if x, ok := m.GetSampler().(*TraceConfig_RateLimitingSampler); ok { - return x.RateLimitingSampler - } - return nil -} - -func (m *TraceConfig) GetMaxNumberOfAttributes() int64 { - if m != nil { - return m.MaxNumberOfAttributes - } - return 0 -} - -func (m *TraceConfig) GetMaxNumberOfTimedEvents() int64 { - if m != nil { - return m.MaxNumberOfTimedEvents - } - return 0 -} - -func (m *TraceConfig) GetMaxNumberOfAttributesPerTimedEvent() int64 { - if m != nil { - return m.MaxNumberOfAttributesPerTimedEvent - } - return 0 -} - -func (m *TraceConfig) GetMaxNumberOfLinks() int64 { - if m != nil { - return m.MaxNumberOfLinks - } - return 0 -} - -func (m *TraceConfig) GetMaxNumberOfAttributesPerLink() int64 { - if m != nil { - return m.MaxNumberOfAttributesPerLink - } - return 0 -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*TraceConfig) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*TraceConfig_ConstantSampler)(nil), - (*TraceConfig_TraceIdRatioBased)(nil), - (*TraceConfig_RateLimitingSampler)(nil), - } -} - -// Sampler that always makes a constant decision on span sampling. -type ConstantSampler struct { - Decision ConstantSampler_ConstantDecision `protobuf:"varint,1,opt,name=decision,proto3,enum=opentelemetry.proto.trace.v1.ConstantSampler_ConstantDecision" json:"decision,omitempty"` -} - -func (m *ConstantSampler) Reset() { *m = ConstantSampler{} } -func (m *ConstantSampler) String() string { return proto.CompactTextString(m) } -func (*ConstantSampler) ProtoMessage() {} -func (*ConstantSampler) Descriptor() ([]byte, []int) { - return fileDescriptor_5936aa8fa6443e6f, []int{1} -} -func (m *ConstantSampler) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ConstantSampler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ConstantSampler.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *ConstantSampler) XXX_Merge(src proto.Message) { - xxx_messageInfo_ConstantSampler.Merge(m, src) -} -func (m *ConstantSampler) XXX_Size() int { - return m.Size() -} -func (m *ConstantSampler) XXX_DiscardUnknown() { - xxx_messageInfo_ConstantSampler.DiscardUnknown(m) -} - -var xxx_messageInfo_ConstantSampler proto.InternalMessageInfo - -func (m *ConstantSampler) GetDecision() ConstantSampler_ConstantDecision { - if m != nil { - return m.Decision - } - return ConstantSampler_ALWAYS_OFF -} - -// Sampler that tries to uniformly sample traces with a given ratio. -// The ratio of sampling a trace is equal to that of the specified ratio. -type TraceIdRatioBased struct { - // The desired ratio of sampling. Must be within [0.0, 1.0]. - SamplingRatio float64 `protobuf:"fixed64,1,opt,name=samplingRatio,proto3" json:"samplingRatio,omitempty"` -} - -func (m *TraceIdRatioBased) Reset() { *m = TraceIdRatioBased{} } -func (m *TraceIdRatioBased) String() string { return proto.CompactTextString(m) } -func (*TraceIdRatioBased) ProtoMessage() {} -func (*TraceIdRatioBased) Descriptor() ([]byte, []int) { - return fileDescriptor_5936aa8fa6443e6f, []int{2} -} -func (m *TraceIdRatioBased) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *TraceIdRatioBased) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_TraceIdRatioBased.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *TraceIdRatioBased) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceIdRatioBased.Merge(m, src) -} -func (m *TraceIdRatioBased) XXX_Size() int { - return m.Size() -} -func (m *TraceIdRatioBased) XXX_DiscardUnknown() { - xxx_messageInfo_TraceIdRatioBased.DiscardUnknown(m) -} - -var xxx_messageInfo_TraceIdRatioBased proto.InternalMessageInfo - -func (m *TraceIdRatioBased) GetSamplingRatio() float64 { - if m != nil { - return m.SamplingRatio - } - return 0 -} - -// Sampler that tries to sample with a rate per time window. -type RateLimitingSampler struct { - // Rate per second. - Qps int64 `protobuf:"varint,1,opt,name=qps,proto3" json:"qps,omitempty"` -} - -func (m *RateLimitingSampler) Reset() { *m = RateLimitingSampler{} } -func (m *RateLimitingSampler) String() string { return proto.CompactTextString(m) } -func (*RateLimitingSampler) ProtoMessage() {} -func (*RateLimitingSampler) Descriptor() ([]byte, []int) { - return fileDescriptor_5936aa8fa6443e6f, []int{3} -} -func (m *RateLimitingSampler) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *RateLimitingSampler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_RateLimitingSampler.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *RateLimitingSampler) XXX_Merge(src proto.Message) { - xxx_messageInfo_RateLimitingSampler.Merge(m, src) -} -func (m *RateLimitingSampler) XXX_Size() int { - return m.Size() -} -func (m *RateLimitingSampler) XXX_DiscardUnknown() { - xxx_messageInfo_RateLimitingSampler.DiscardUnknown(m) -} - -var xxx_messageInfo_RateLimitingSampler proto.InternalMessageInfo - -func (m *RateLimitingSampler) GetQps() int64 { - if m != nil { - return m.Qps - } - return 0 -} - -func init() { - proto.RegisterEnum("opentelemetry.proto.trace.v1.ConstantSampler_ConstantDecision", ConstantSampler_ConstantDecision_name, ConstantSampler_ConstantDecision_value) - proto.RegisterType((*TraceConfig)(nil), "opentelemetry.proto.trace.v1.TraceConfig") - proto.RegisterType((*ConstantSampler)(nil), "opentelemetry.proto.trace.v1.ConstantSampler") - proto.RegisterType((*TraceIdRatioBased)(nil), "opentelemetry.proto.trace.v1.TraceIdRatioBased") - proto.RegisterType((*RateLimitingSampler)(nil), "opentelemetry.proto.trace.v1.RateLimitingSampler") -} - -func init() { - proto.RegisterFile("opentelemetry/proto/trace/v1/trace_config.proto", fileDescriptor_5936aa8fa6443e6f) -} - -var fileDescriptor_5936aa8fa6443e6f = []byte{ - // 563 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x94, 0xcd, 0x6e, 0xd3, 0x40, - 0x14, 0x85, 0xed, 0x86, 0xfe, 0xdd, 0xaa, 0xad, 0x3b, 0x6d, 0x91, 0x55, 0x55, 0xa6, 0x58, 0x48, - 0x64, 0xd3, 0x58, 0x29, 0x0b, 0x04, 0x0b, 0xa4, 0xa4, 0x3f, 0x14, 0x29, 0xa4, 0x91, 0x1b, 0x09, - 0x91, 0xcd, 0x68, 0x62, 0x4f, 0xac, 0x11, 0xf6, 0x8c, 0x19, 0x4f, 0xa3, 0xb2, 0xe7, 0x01, 0x78, - 0x00, 0xde, 0x82, 0x97, 0x60, 0xd9, 0x25, 0x4b, 0x94, 0xbc, 0x08, 0xf2, 0x38, 0x4d, 0x93, 0xb4, - 0x8d, 0xc4, 0x6e, 0xee, 0x39, 0x73, 0xbe, 0x7b, 0x27, 0xb9, 0x09, 0x78, 0x22, 0xa5, 0x5c, 0xd1, - 0x98, 0x26, 0x54, 0xc9, 0x6f, 0x5e, 0x2a, 0x85, 0x12, 0x9e, 0x92, 0x24, 0xa0, 0x5e, 0xbf, 0x5a, - 0x1c, 0x70, 0x20, 0x78, 0x8f, 0x45, 0x15, 0xed, 0xa1, 0xfd, 0xa9, 0x40, 0x21, 0x56, 0xf4, 0xbd, - 0x4a, 0xbf, 0xba, 0xb7, 0x13, 0x89, 0x48, 0x14, 0x90, 0xfc, 0x54, 0xd8, 0xee, 0xf7, 0x45, 0x58, - 0x6b, 0xe7, 0x57, 0x8e, 0x35, 0x09, 0x75, 0xc0, 0x0a, 0x04, 0xcf, 0x14, 0xe1, 0x0a, 0x67, 0x24, - 0x49, 0x63, 0x2a, 0x6d, 0xf3, 0xc0, 0x2c, 0xaf, 0x1d, 0x1d, 0x56, 0xe6, 0xe1, 0x2b, 0xc7, 0xa3, - 0xd4, 0x65, 0x11, 0x3a, 0x37, 0xfc, 0xcd, 0x60, 0x5a, 0x42, 0x5d, 0xd8, 0x29, 0xa6, 0x66, 0x21, - 0x96, 0x44, 0x31, 0x81, 0xbb, 0x24, 0xa3, 0xa1, 0xbd, 0xa0, 0xf9, 0xde, 0x7c, 0xbe, 0x1e, 0xf2, - 0x43, 0xe8, 0xe7, 0xb9, 0x7a, 0x1e, 0x3b, 0x37, 0xfc, 0x2d, 0x35, 0x2b, 0xa2, 0x08, 0x76, 0x25, - 0x51, 0x14, 0xc7, 0x2c, 0x61, 0x8a, 0xf1, 0x68, 0xfc, 0x88, 0x92, 0x6e, 0x52, 0x9d, 0xdf, 0xc4, - 0x27, 0x8a, 0x36, 0x46, 0xc9, 0xbb, 0x87, 0x6c, 0xcb, 0xfb, 0x32, 0x7a, 0x0d, 0x76, 0x42, 0xae, - 0x31, 0xbf, 0x4a, 0xba, 0x54, 0x62, 0xd1, 0xc3, 0x44, 0x29, 0xc9, 0xba, 0x57, 0x8a, 0x66, 0xf6, - 0x93, 0x03, 0xb3, 0x5c, 0xf2, 0x77, 0x13, 0x72, 0xdd, 0xd4, 0xf6, 0x45, 0xaf, 0x36, 0x36, 0xd1, - 0x5b, 0xd8, 0x9b, 0x0e, 0x2a, 0x96, 0xd0, 0x10, 0xd3, 0x3e, 0xe5, 0x2a, 0xb3, 0x17, 0x75, 0xf4, - 0xe9, 0x44, 0xb4, 0x9d, 0xdb, 0xa7, 0xda, 0x45, 0x6d, 0x28, 0x3f, 0xd6, 0x14, 0xa7, 0x54, 0x4e, - 0xa2, 0xec, 0x25, 0x4d, 0x72, 0x1f, 0x1c, 0xa2, 0x45, 0xe5, 0x1d, 0x16, 0x1d, 0xc2, 0xf6, 0x34, - 0x35, 0x66, 0xfc, 0x4b, 0x66, 0x2f, 0x6b, 0x80, 0x35, 0x01, 0x68, 0xe4, 0x3a, 0x7a, 0x0f, 0xcf, - 0xe7, 0x0e, 0x91, 0xa7, 0xed, 0x15, 0x1d, 0xde, 0x7f, 0xac, 0x7b, 0x4e, 0xaa, 0xaf, 0xc2, 0xf2, - 0xe8, 0xdb, 0x71, 0x7f, 0x99, 0xb0, 0x39, 0xb3, 0x41, 0xa8, 0x03, 0x2b, 0x21, 0x0d, 0x58, 0xc6, - 0x04, 0xd7, 0x2b, 0xb8, 0x71, 0xf4, 0xee, 0xbf, 0x56, 0x70, 0x5c, 0x9f, 0x8c, 0x28, 0xfe, 0x98, - 0xe7, 0x9e, 0x80, 0x35, 0xeb, 0xa2, 0x0d, 0x80, 0x5a, 0xe3, 0x53, 0xed, 0xf3, 0x25, 0xbe, 0x38, - 0x3b, 0xb3, 0x0c, 0xb4, 0x0e, 0xab, 0xb7, 0x75, 0xd3, 0x32, 0xd1, 0x16, 0xac, 0x8f, 0xca, 0x56, - 0xcd, 0x3f, 0x6d, 0xb6, 0xad, 0x05, 0xf7, 0x0d, 0x6c, 0xdd, 0x5b, 0x4b, 0xf4, 0x02, 0xd6, 0xf5, - 0xab, 0x18, 0x8f, 0xb4, 0xaa, 0x67, 0x37, 0xfd, 0x69, 0xd1, 0x7d, 0x09, 0xdb, 0x0f, 0x2c, 0x1b, - 0xb2, 0xa0, 0xf4, 0x35, 0xcd, 0x74, 0xa4, 0xe4, 0xe7, 0xc7, 0xfa, 0x4f, 0xf3, 0xf7, 0xc0, 0x31, - 0x6f, 0x06, 0x8e, 0xf9, 0x77, 0xe0, 0x98, 0x3f, 0x86, 0x8e, 0x71, 0x33, 0x74, 0x8c, 0x3f, 0x43, - 0xc7, 0x80, 0x67, 0x4c, 0xcc, 0xfd, 0x40, 0xea, 0xd6, 0xc4, 0x2f, 0xbb, 0x95, 0x5b, 0x2d, 0xb3, - 0xf3, 0x31, 0x9a, 0x0d, 0x31, 0xe1, 0x05, 0x22, 0x8e, 0x69, 0xa0, 0x84, 0xf4, 0xd2, 0x90, 0x28, - 0xe2, 0x31, 0xae, 0xa8, 0xe4, 0x24, 0xf6, 0x74, 0xa5, 0xa9, 0x11, 0xe5, 0x13, 0xd7, 0x6e, 0xff, - 0x86, 0xba, 0x4b, 0xda, 0x7c, 0xf5, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x0e, 0xd1, 0x4d, 0x12, 0xad, - 0x04, 0x00, 0x00, -} - -func (m *TraceConfig) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *TraceConfig) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TraceConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.MaxNumberOfAttributesPerLink != 0 { - i = encodeVarintTraceConfig(dAtA, i, uint64(m.MaxNumberOfAttributesPerLink)) - i-- - dAtA[i] = 0x40 - } - if m.MaxNumberOfLinks != 0 { - i = encodeVarintTraceConfig(dAtA, i, uint64(m.MaxNumberOfLinks)) - i-- - dAtA[i] = 0x38 - } - if m.MaxNumberOfAttributesPerTimedEvent != 0 { - i = encodeVarintTraceConfig(dAtA, i, uint64(m.MaxNumberOfAttributesPerTimedEvent)) - i-- - dAtA[i] = 0x30 - } - if m.MaxNumberOfTimedEvents != 0 { - i = encodeVarintTraceConfig(dAtA, i, uint64(m.MaxNumberOfTimedEvents)) - i-- - dAtA[i] = 0x28 - } - if m.MaxNumberOfAttributes != 0 { - i = encodeVarintTraceConfig(dAtA, i, uint64(m.MaxNumberOfAttributes)) - i-- - dAtA[i] = 0x20 - } - if m.Sampler != nil { - { - size := m.Sampler.Size() - i -= size - if _, err := m.Sampler.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *TraceConfig_ConstantSampler) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TraceConfig_ConstantSampler) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.ConstantSampler != nil { - { - size, err := m.ConstantSampler.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTraceConfig(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *TraceConfig_TraceIdRatioBased) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TraceConfig_TraceIdRatioBased) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.TraceIdRatioBased != nil { - { - size, err := m.TraceIdRatioBased.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTraceConfig(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *TraceConfig_RateLimitingSampler) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TraceConfig_RateLimitingSampler) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.RateLimitingSampler != nil { - { - size, err := m.RateLimitingSampler.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTraceConfig(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - return len(dAtA) - i, nil -} -func (m *ConstantSampler) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *ConstantSampler) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ConstantSampler) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Decision != 0 { - i = encodeVarintTraceConfig(dAtA, i, uint64(m.Decision)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *TraceIdRatioBased) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *TraceIdRatioBased) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TraceIdRatioBased) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.SamplingRatio != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.SamplingRatio)))) - i-- - dAtA[i] = 0x9 - } - return len(dAtA) - i, nil -} - -func (m *RateLimitingSampler) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *RateLimitingSampler) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *RateLimitingSampler) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Qps != 0 { - i = encodeVarintTraceConfig(dAtA, i, uint64(m.Qps)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func encodeVarintTraceConfig(dAtA []byte, offset int, v uint64) int { - offset -= sovTraceConfig(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *TraceConfig) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Sampler != nil { - n += m.Sampler.Size() - } - if m.MaxNumberOfAttributes != 0 { - n += 1 + sovTraceConfig(uint64(m.MaxNumberOfAttributes)) - } - if m.MaxNumberOfTimedEvents != 0 { - n += 1 + sovTraceConfig(uint64(m.MaxNumberOfTimedEvents)) - } - if m.MaxNumberOfAttributesPerTimedEvent != 0 { - n += 1 + sovTraceConfig(uint64(m.MaxNumberOfAttributesPerTimedEvent)) - } - if m.MaxNumberOfLinks != 0 { - n += 1 + sovTraceConfig(uint64(m.MaxNumberOfLinks)) - } - if m.MaxNumberOfAttributesPerLink != 0 { - n += 1 + sovTraceConfig(uint64(m.MaxNumberOfAttributesPerLink)) - } - return n -} - -func (m *TraceConfig_ConstantSampler) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ConstantSampler != nil { - l = m.ConstantSampler.Size() - n += 1 + l + sovTraceConfig(uint64(l)) - } - return n -} -func (m *TraceConfig_TraceIdRatioBased) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.TraceIdRatioBased != nil { - l = m.TraceIdRatioBased.Size() - n += 1 + l + sovTraceConfig(uint64(l)) - } - return n -} -func (m *TraceConfig_RateLimitingSampler) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.RateLimitingSampler != nil { - l = m.RateLimitingSampler.Size() - n += 1 + l + sovTraceConfig(uint64(l)) - } - return n -} -func (m *ConstantSampler) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Decision != 0 { - n += 1 + sovTraceConfig(uint64(m.Decision)) - } - return n -} - -func (m *TraceIdRatioBased) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SamplingRatio != 0 { - n += 9 - } - return n -} - -func (m *RateLimitingSampler) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Qps != 0 { - n += 1 + sovTraceConfig(uint64(m.Qps)) - } - return n -} - -func sovTraceConfig(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozTraceConfig(x uint64) (n int) { - return sovTraceConfig(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *TraceConfig) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: TraceConfig: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TraceConfig: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConstantSampler", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTraceConfig - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTraceConfig - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ConstantSampler{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Sampler = &TraceConfig_ConstantSampler{v} - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TraceIdRatioBased", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTraceConfig - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTraceConfig - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &TraceIdRatioBased{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Sampler = &TraceConfig_TraceIdRatioBased{v} - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RateLimitingSampler", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTraceConfig - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTraceConfig - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &RateLimitingSampler{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Sampler = &TraceConfig_RateLimitingSampler{v} - iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfAttributes", wireType) - } - m.MaxNumberOfAttributes = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MaxNumberOfAttributes |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfTimedEvents", wireType) - } - m.MaxNumberOfTimedEvents = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MaxNumberOfTimedEvents |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfAttributesPerTimedEvent", wireType) - } - m.MaxNumberOfAttributesPerTimedEvent = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MaxNumberOfAttributesPerTimedEvent |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfLinks", wireType) - } - m.MaxNumberOfLinks = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MaxNumberOfLinks |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 8: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfAttributesPerLink", wireType) - } - m.MaxNumberOfAttributesPerLink = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MaxNumberOfAttributesPerLink |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipTraceConfig(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTraceConfig - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ConstantSampler) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ConstantSampler: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ConstantSampler: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Decision", wireType) - } - m.Decision = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Decision |= ConstantSampler_ConstantDecision(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipTraceConfig(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTraceConfig - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TraceIdRatioBased) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: TraceIdRatioBased: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TraceIdRatioBased: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field SamplingRatio", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.SamplingRatio = float64(math.Float64frombits(v)) - default: - iNdEx = preIndex - skippy, err := skipTraceConfig(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTraceConfig - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *RateLimitingSampler) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: RateLimitingSampler: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RateLimitingSampler: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Qps", wireType) - } - m.Qps = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Qps |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipTraceConfig(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTraceConfig - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipTraceConfig(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowTraceConfig - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthTraceConfig - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupTraceConfig - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthTraceConfig - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthTraceConfig = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowTraceConfig = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupTraceConfig = fmt.Errorf("proto: unexpected end of group") -) diff --git a/pdata/internal/data/protogen/collector/trace/v1/trace_service.pb.go b/pdata/internal/data/protogen/collector/trace/v1/trace_service.pb.go index 0a294a27ece..60569425180 100644 --- a/pdata/internal/data/protogen/collector/trace/v1/trace_service.pb.go +++ b/pdata/internal/data/protogen/collector/trace/v1/trace_service.pb.go @@ -80,6 +80,22 @@ func (m *ExportTraceServiceRequest) GetResourceSpans() []*v1.ResourceSpans { } type ExportTraceServiceResponse struct { + // The details of a partially successful export request. + // + // If the request is only partially accepted + // (i.e. when the server accepts only parts of the data and rejects the rest) + // the server MUST initialize the `partial_success` field and MUST + // set the `rejected_` with the number of items it rejected. + // + // Servers MAY also make use of the `partial_success` field to convey + // warnings/suggestions to senders even when the request was fully accepted. + // In such cases, the `rejected_` MUST have a value of `0` and + // the `error_message` MUST be non-empty. + // + // A `partial_success` message with an empty value (rejected_ = 0 and + // `error_message` = "") is equivalent to it not being set/present. Senders + // SHOULD interpret it the same way as in the full success case. + PartialSuccess *ExportTracePartialSuccess `protobuf:"bytes,1,opt,name=partial_success,json=partialSuccess,proto3" json:"partial_success,omitempty"` } func (m *ExportTraceServiceResponse) Reset() { *m = ExportTraceServiceResponse{} } @@ -115,9 +131,80 @@ func (m *ExportTraceServiceResponse) XXX_DiscardUnknown() { var xxx_messageInfo_ExportTraceServiceResponse proto.InternalMessageInfo +func (m *ExportTraceServiceResponse) GetPartialSuccess() *ExportTracePartialSuccess { + if m != nil { + return m.PartialSuccess + } + return nil +} + +type ExportTracePartialSuccess struct { + // The number of rejected spans. + // + // A `rejected_` field holding a `0` value indicates that the + // request was fully accepted. + RejectedSpans int64 `protobuf:"varint,1,opt,name=rejected_spans,json=rejectedSpans,proto3" json:"rejected_spans,omitempty"` + // A developer-facing human-readable message in English. It should be used + // either to explain why the server rejected parts of the data during a partial + // success or to convey warnings/suggestions during a full success. The message + // should offer guidance on how users can address such issues. + // + // error_message is an optional field. An error_message with an empty value + // is equivalent to it not being set. + ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"` +} + +func (m *ExportTracePartialSuccess) Reset() { *m = ExportTracePartialSuccess{} } +func (m *ExportTracePartialSuccess) String() string { return proto.CompactTextString(m) } +func (*ExportTracePartialSuccess) ProtoMessage() {} +func (*ExportTracePartialSuccess) Descriptor() ([]byte, []int) { + return fileDescriptor_192a962890318cf4, []int{2} +} +func (m *ExportTracePartialSuccess) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExportTracePartialSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExportTracePartialSuccess.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ExportTracePartialSuccess) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExportTracePartialSuccess.Merge(m, src) +} +func (m *ExportTracePartialSuccess) XXX_Size() int { + return m.Size() +} +func (m *ExportTracePartialSuccess) XXX_DiscardUnknown() { + xxx_messageInfo_ExportTracePartialSuccess.DiscardUnknown(m) +} + +var xxx_messageInfo_ExportTracePartialSuccess proto.InternalMessageInfo + +func (m *ExportTracePartialSuccess) GetRejectedSpans() int64 { + if m != nil { + return m.RejectedSpans + } + return 0 +} + +func (m *ExportTracePartialSuccess) GetErrorMessage() string { + if m != nil { + return m.ErrorMessage + } + return "" +} + func init() { proto.RegisterType((*ExportTraceServiceRequest)(nil), "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest") proto.RegisterType((*ExportTraceServiceResponse)(nil), "opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse") + proto.RegisterType((*ExportTracePartialSuccess)(nil), "opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess") } func init() { @@ -125,26 +212,33 @@ func init() { } var fileDescriptor_192a962890318cf4 = []byte{ - // 302 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x52, 0xbf, 0x4a, 0xc4, 0x30, - 0x18, 0x6f, 0x10, 0x6e, 0x88, 0x7f, 0xc0, 0xe2, 0xa0, 0x45, 0x82, 0xdc, 0x20, 0x27, 0x42, 0xc2, - 0x9d, 0x9b, 0x9b, 0x05, 0x47, 0xe1, 0xe8, 0x39, 0xb9, 0x48, 0xad, 0x1f, 0xa5, 0x50, 0xf3, 0xc5, - 0x24, 0x57, 0xf4, 0x2d, 0xf4, 0x15, 0x5c, 0x7c, 0x15, 0xc7, 0x1b, 0x1d, 0xa5, 0x7d, 0x11, 0x69, - 0xa2, 0xd2, 0x93, 0x0a, 0x07, 0x6e, 0xdf, 0x9f, 0xdf, 0xbf, 0x84, 0x8f, 0x9e, 0xa2, 0x02, 0x69, - 0xa1, 0x84, 0x3b, 0xb0, 0xfa, 0x51, 0x28, 0x8d, 0x16, 0x45, 0x86, 0x65, 0x09, 0x99, 0x45, 0x2d, - 0xac, 0x4e, 0x33, 0x10, 0xd5, 0xd8, 0x17, 0xd7, 0x06, 0x74, 0x55, 0x64, 0xc0, 0x1d, 0x2c, 0x3c, - 0x5c, 0xe2, 0xfa, 0x21, 0xff, 0xe1, 0x72, 0x47, 0xe1, 0xd5, 0x38, 0xda, 0xc9, 0x31, 0x47, 0xaf, - 0xdc, 0x56, 0x1e, 0x18, 0x8d, 0xfa, 0x9c, 0x97, 0xfd, 0x3c, 0x72, 0x88, 0x74, 0xef, 0xfc, 0x41, - 0xa1, 0xb6, 0x97, 0xed, 0x70, 0xe6, 0x33, 0x24, 0x70, 0x3f, 0x07, 0x63, 0xc3, 0x84, 0x6e, 0x69, - 0x30, 0x38, 0xd7, 0x6d, 0x3c, 0x95, 0x4a, 0xb3, 0x4b, 0x0e, 0xd6, 0x46, 0xeb, 0x93, 0x63, 0xde, - 0x97, 0xee, 0x3b, 0x13, 0x4f, 0xbe, 0x38, 0xb3, 0x96, 0x92, 0x6c, 0xea, 0x6e, 0x3b, 0xdc, 0xa7, - 0x51, 0x9f, 0xa1, 0x51, 0x28, 0x0d, 0x4c, 0x5e, 0x08, 0xdd, 0xe8, 0x2e, 0xc2, 0x67, 0x42, 0x07, - 0x1e, 0x1f, 0x9e, 0xf1, 0xd5, 0xfe, 0x84, 0xff, 0xf9, 0xa0, 0x28, 0xfe, 0x8f, 0x84, 0x8f, 0x38, - 0x0c, 0xe2, 0x57, 0xf2, 0x56, 0x33, 0xb2, 0xa8, 0x19, 0xf9, 0xa8, 0x19, 0x79, 0x6a, 0x58, 0xb0, - 0x68, 0x58, 0xf0, 0xde, 0xb0, 0x80, 0x1e, 0x15, 0xb8, 0xa2, 0x45, 0xbc, 0xdd, 0x55, 0x9f, 0xb6, - 0xa8, 0x29, 0xb9, 0xba, 0xc8, 0x7f, 0xf3, 0x8b, 0xee, 0xc9, 0xa8, 0xdb, 0xd4, 0xa6, 0xa2, 0x90, - 0x16, 0xb4, 0x4c, 0x4b, 0xe1, 0x3a, 0x67, 0x90, 0x83, 0xec, 0xb9, 0xac, 0x9b, 0x81, 0x5b, 0x9e, - 0x7c, 0x06, 0x00, 0x00, 0xff, 0xff, 0xb7, 0x91, 0xe9, 0x89, 0x8a, 0x02, 0x00, 0x00, + // 408 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x53, 0xbf, 0x8a, 0xdb, 0x30, + 0x18, 0xb7, 0x12, 0x08, 0x54, 0xf9, 0x53, 0x6a, 0x3a, 0xa4, 0x1e, 0x4c, 0x70, 0x69, 0x70, 0x29, + 0xc8, 0x24, 0xdd, 0xba, 0x35, 0xa5, 0x63, 0x68, 0x70, 0x42, 0x87, 0x2e, 0x41, 0x75, 0x3e, 0x8c, + 0x83, 0x63, 0xa9, 0x92, 0x12, 0xda, 0x37, 0xe8, 0xd8, 0xbe, 0x42, 0xc7, 0x3e, 0xc9, 0x8d, 0x19, + 0x6f, 0x3c, 0x92, 0x17, 0x39, 0x24, 0xdd, 0x19, 0xfb, 0xf0, 0x10, 0xee, 0x36, 0x7d, 0x1f, 0xbf, + 0xbf, 0x12, 0xc2, 0x1f, 0x18, 0x87, 0x42, 0x41, 0x0e, 0x3b, 0x50, 0xe2, 0x57, 0xc4, 0x05, 0x53, + 0x2c, 0x4a, 0x58, 0x9e, 0x43, 0xa2, 0x98, 0x88, 0x94, 0xa0, 0x09, 0x44, 0x87, 0x89, 0x3d, 0xac, + 0x25, 0x88, 0x43, 0x96, 0x00, 0x31, 0x30, 0x77, 0x5c, 0xe3, 0xda, 0x25, 0x29, 0xb9, 0xc4, 0x50, + 0xc8, 0x61, 0xe2, 0xbd, 0x4c, 0x59, 0xca, 0xac, 0xb2, 0x3e, 0x59, 0xa0, 0x17, 0x36, 0x39, 0xd7, + 0xfd, 0x2c, 0x32, 0x60, 0xf8, 0xd5, 0xe7, 0x9f, 0x9c, 0x09, 0xb5, 0xd2, 0xcb, 0xa5, 0xcd, 0x10, + 0xc3, 0x8f, 0x3d, 0x48, 0xe5, 0xc6, 0x78, 0x20, 0x40, 0xb2, 0xbd, 0xd0, 0xf1, 0x38, 0x2d, 0xe4, + 0x10, 0x8d, 0xda, 0x61, 0x77, 0xfa, 0x8e, 0x34, 0xa5, 0xbb, 0xcf, 0x44, 0xe2, 0x3b, 0xce, 0x52, + 0x53, 0xe2, 0xbe, 0xa8, 0x8e, 0xc1, 0x6f, 0x84, 0xbd, 0x26, 0x47, 0xc9, 0x59, 0x21, 0xc1, 0xdd, + 0xe2, 0xe7, 0x9c, 0x0a, 0x95, 0xd1, 0x7c, 0x2d, 0xf7, 0x49, 0x02, 0x52, 0x7b, 0xa2, 0xb0, 0x3b, + 0xfd, 0x48, 0x2e, 0xbb, 0x11, 0x52, 0x11, 0x5f, 0x58, 0xa5, 0xa5, 0x15, 0x8a, 0x07, 0xbc, 0x36, + 0x07, 0x69, 0xad, 0x7b, 0x1d, 0xec, 0xbe, 0xd1, 0xdd, 0xb7, 0x90, 0x28, 0xd8, 0x94, 0xdd, 0x51, + 0xd8, 0xd6, 0x75, 0xec, 0xd6, 0xd4, 0x71, 0x5f, 0xe3, 0x3e, 0x08, 0xc1, 0xc4, 0x7a, 0x07, 0x52, + 0xd2, 0x14, 0x86, 0xad, 0x11, 0x0a, 0x9f, 0xc5, 0x3d, 0xb3, 0x9c, 0xdb, 0xdd, 0xf4, 0x1f, 0xc2, + 0xbd, 0x6a, 0x5b, 0xf7, 0x2f, 0xc2, 0x1d, 0x6b, 0xed, 0x3e, 0xa6, 0x57, 0xfd, 0x99, 0xbc, 0xd9, + 0x53, 0x24, 0xec, 0xbd, 0x07, 0xce, 0xec, 0x88, 0xae, 0x4e, 0x3e, 0x3a, 0x9e, 0x7c, 0x74, 0x73, + 0xf2, 0xd1, 0x9f, 0xb3, 0xef, 0x1c, 0xcf, 0xbe, 0x73, 0x7d, 0xf6, 0x1d, 0xfc, 0x36, 0x63, 0x17, + 0x5a, 0xcc, 0x5e, 0x54, 0xd5, 0x17, 0x1a, 0xb5, 0x40, 0xdf, 0xe6, 0xe9, 0x43, 0x7e, 0x56, 0xfd, + 0x08, 0x7c, 0x43, 0x15, 0x8d, 0xb2, 0x42, 0x81, 0x28, 0x68, 0x1e, 0x99, 0xc9, 0x18, 0xa4, 0x50, + 0x34, 0xfc, 0x97, 0xff, 0xad, 0xf1, 0x17, 0x0e, 0xc5, 0xaa, 0x14, 0x33, 0x36, 0xe4, 0x53, 0x19, + 0xc6, 0x44, 0x20, 0x5f, 0x27, 0xdf, 0x3b, 0x46, 0xe5, 0xfd, 0x6d, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x78, 0x38, 0xde, 0xea, 0x89, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -288,6 +382,53 @@ func (m *ExportTraceServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, err _ = i var l int _ = l + if m.PartialSuccess != nil { + { + size, err := m.PartialSuccess.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTraceService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExportTracePartialSuccess) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExportTracePartialSuccess) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExportTracePartialSuccess) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ErrorMessage) > 0 { + i -= len(m.ErrorMessage) + copy(dAtA[i:], m.ErrorMessage) + i = encodeVarintTraceService(dAtA, i, uint64(len(m.ErrorMessage))) + i-- + dAtA[i] = 0x12 + } + if m.RejectedSpans != 0 { + i = encodeVarintTraceService(dAtA, i, uint64(m.RejectedSpans)) + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } @@ -323,6 +464,26 @@ func (m *ExportTraceServiceResponse) Size() (n int) { } var l int _ = l + if m.PartialSuccess != nil { + l = m.PartialSuccess.Size() + n += 1 + l + sovTraceService(uint64(l)) + } + return n +} + +func (m *ExportTracePartialSuccess) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RejectedSpans != 0 { + n += 1 + sovTraceService(uint64(m.RejectedSpans)) + } + l = len(m.ErrorMessage) + if l > 0 { + n += 1 + l + sovTraceService(uint64(l)) + } return n } @@ -445,6 +606,143 @@ func (m *ExportTraceServiceResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: ExportTraceServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PartialSuccess", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTraceService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTraceService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTraceService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PartialSuccess == nil { + m.PartialSuccess = &ExportTracePartialSuccess{} + } + if err := m.PartialSuccess.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTraceService(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTraceService + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExportTracePartialSuccess) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTraceService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExportTracePartialSuccess: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExportTracePartialSuccess: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RejectedSpans", wireType) + } + m.RejectedSpans = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTraceService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RejectedSpans |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ErrorMessage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTraceService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTraceService + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTraceService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ErrorMessage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTraceService(dAtA[iNdEx:]) diff --git a/pdata/internal/data/protogen/common/v1/common.pb.go b/pdata/internal/data/protogen/common/v1/common.pb.go index c15aff30d5e..a6085676496 100644 --- a/pdata/internal/data/protogen/common/v1/common.pb.go +++ b/pdata/internal/data/protogen/common/v1/common.pb.go @@ -335,79 +335,21 @@ func (m *KeyValue) GetValue() AnyValue { return AnyValue{} } -// InstrumentationLibrary is a message representing the instrumentation library information -// such as the fully qualified name and version. -// InstrumentationLibrary is wire-compatible with InstrumentationScope for binary -// Protobuf format. -// This message is deprecated and will be removed on June 15, 2022. -// -// Deprecated: Do not use. -type InstrumentationLibrary struct { - // An empty instrumentation library name means the name is unknown. - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` -} - -func (m *InstrumentationLibrary) Reset() { *m = InstrumentationLibrary{} } -func (m *InstrumentationLibrary) String() string { return proto.CompactTextString(m) } -func (*InstrumentationLibrary) ProtoMessage() {} -func (*InstrumentationLibrary) Descriptor() ([]byte, []int) { - return fileDescriptor_62ba46dcb97aa817, []int{4} -} -func (m *InstrumentationLibrary) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *InstrumentationLibrary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_InstrumentationLibrary.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *InstrumentationLibrary) XXX_Merge(src proto.Message) { - xxx_messageInfo_InstrumentationLibrary.Merge(m, src) -} -func (m *InstrumentationLibrary) XXX_Size() int { - return m.Size() -} -func (m *InstrumentationLibrary) XXX_DiscardUnknown() { - xxx_messageInfo_InstrumentationLibrary.DiscardUnknown(m) -} - -var xxx_messageInfo_InstrumentationLibrary proto.InternalMessageInfo - -func (m *InstrumentationLibrary) GetName() string { - if m != nil { - return m.Name - } - return "" -} - -func (m *InstrumentationLibrary) GetVersion() string { - if m != nil { - return m.Version - } - return "" -} - // InstrumentationScope is a message representing the instrumentation scope information // such as the fully qualified name and version. type InstrumentationScope struct { // An empty instrumentation scope name means the name is unknown. - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` + Attributes []KeyValue `protobuf:"bytes,3,rep,name=attributes,proto3" json:"attributes"` + DroppedAttributesCount uint32 `protobuf:"varint,4,opt,name=dropped_attributes_count,json=droppedAttributesCount,proto3" json:"dropped_attributes_count,omitempty"` } func (m *InstrumentationScope) Reset() { *m = InstrumentationScope{} } func (m *InstrumentationScope) String() string { return proto.CompactTextString(m) } func (*InstrumentationScope) ProtoMessage() {} func (*InstrumentationScope) Descriptor() ([]byte, []int) { - return fileDescriptor_62ba46dcb97aa817, []int{5} + return fileDescriptor_62ba46dcb97aa817, []int{4} } func (m *InstrumentationScope) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -450,12 +392,25 @@ func (m *InstrumentationScope) GetVersion() string { return "" } +func (m *InstrumentationScope) GetAttributes() []KeyValue { + if m != nil { + return m.Attributes + } + return nil +} + +func (m *InstrumentationScope) GetDroppedAttributesCount() uint32 { + if m != nil { + return m.DroppedAttributesCount + } + return 0 +} + func init() { proto.RegisterType((*AnyValue)(nil), "opentelemetry.proto.common.v1.AnyValue") proto.RegisterType((*ArrayValue)(nil), "opentelemetry.proto.common.v1.ArrayValue") proto.RegisterType((*KeyValueList)(nil), "opentelemetry.proto.common.v1.KeyValueList") proto.RegisterType((*KeyValue)(nil), "opentelemetry.proto.common.v1.KeyValue") - proto.RegisterType((*InstrumentationLibrary)(nil), "opentelemetry.proto.common.v1.InstrumentationLibrary") proto.RegisterType((*InstrumentationScope)(nil), "opentelemetry.proto.common.v1.InstrumentationScope") } @@ -464,38 +419,41 @@ func init() { } var fileDescriptor_62ba46dcb97aa817 = []byte{ - // 484 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0x4d, 0x6f, 0xd3, 0x40, - 0x10, 0xf5, 0x26, 0x69, 0x3e, 0xc6, 0x39, 0xa0, 0x55, 0x85, 0x22, 0xa4, 0xba, 0x26, 0x1c, 0x30, - 0x20, 0xc5, 0x6a, 0xb9, 0x71, 0x6b, 0x5a, 0xa4, 0x00, 0x39, 0x44, 0xae, 0xe0, 0xc0, 0x05, 0xad, - 0xd3, 0x95, 0xb5, 0xaa, 0xbd, 0x1b, 0xad, 0x37, 0x96, 0xfc, 0x2b, 0xe0, 0x67, 0xf5, 0xd8, 0x23, - 0x27, 0x54, 0x25, 0x7f, 0x04, 0xed, 0x87, 0x5b, 0xc8, 0xa1, 0x55, 0x6e, 0x33, 0x6f, 0xde, 0x7b, - 0x33, 0xb3, 0x1f, 0xf0, 0x56, 0xac, 0x28, 0x57, 0x34, 0xa7, 0x05, 0x55, 0xb2, 0x8e, 0x57, 0x52, - 0x28, 0x11, 0x2f, 0x45, 0x51, 0x08, 0x1e, 0x57, 0x27, 0x2e, 0x9a, 0x18, 0x18, 0x1f, 0xfd, 0xc7, - 0xb5, 0xe0, 0xc4, 0x31, 0xaa, 0x93, 0x17, 0x87, 0x99, 0xc8, 0x84, 0x35, 0xd0, 0x91, 0xad, 0x8f, - 0xef, 0x5a, 0xd0, 0x3f, 0xe3, 0xf5, 0x37, 0x92, 0xaf, 0x29, 0x7e, 0x05, 0xc3, 0x52, 0x49, 0xc6, - 0xb3, 0x1f, 0x95, 0xce, 0x47, 0x28, 0x44, 0xd1, 0x60, 0xe6, 0x25, 0xbe, 0x45, 0x2d, 0xe9, 0x18, - 0x20, 0x15, 0x22, 0x77, 0x94, 0x56, 0x88, 0xa2, 0xfe, 0xcc, 0x4b, 0x06, 0x1a, 0xb3, 0x84, 0x23, - 0x18, 0x30, 0xae, 0x5c, 0xbd, 0x1d, 0xa2, 0xa8, 0x3d, 0xf3, 0x92, 0x3e, 0xe3, 0xea, 0xbe, 0xc9, - 0x95, 0x58, 0xa7, 0x39, 0x75, 0x8c, 0x4e, 0x88, 0x22, 0xa4, 0x9b, 0x58, 0xd4, 0x92, 0xe6, 0xe0, - 0x13, 0x29, 0x49, 0xed, 0x38, 0x07, 0x21, 0x8a, 0xfc, 0xd3, 0x37, 0x93, 0x47, 0x37, 0x9c, 0x9c, - 0x69, 0x85, 0xd1, 0xcf, 0xbc, 0x04, 0xc8, 0x7d, 0x86, 0x17, 0x30, 0xbc, 0xae, 0x72, 0x56, 0x36, - 0x43, 0x75, 0x8d, 0xdd, 0xbb, 0x27, 0xec, 0xbe, 0x50, 0x2b, 0x9f, 0xb3, 0x52, 0xe9, 0xf9, 0xac, - 0x85, 0x75, 0x7c, 0x09, 0x7e, 0x5a, 0x2b, 0x5a, 0x3a, 0xc3, 0x5e, 0x88, 0xa2, 0xa1, 0x6e, 0x6a, - 0x40, 0x43, 0x99, 0xf6, 0xe0, 0xc0, 0x14, 0xc7, 0x97, 0x00, 0x0f, 0x93, 0xe1, 0x8f, 0xd0, 0x35, - 0x70, 0x39, 0x42, 0x61, 0x3b, 0xf2, 0x4f, 0x5f, 0x3f, 0xb5, 0x94, 0xbb, 0x9c, 0x69, 0xe7, 0xe6, - 0xcf, 0xb1, 0x97, 0x38, 0xf1, 0xf8, 0x2b, 0x0c, 0xff, 0x9d, 0x6f, 0x6f, 0xdb, 0x46, 0xbc, 0x63, - 0x4b, 0xa0, 0xdf, 0x54, 0xf0, 0x33, 0x68, 0x5f, 0xd3, 0xda, 0x3e, 0x82, 0x44, 0x87, 0xf8, 0xdc, - 0xad, 0x64, 0x6e, 0x7d, 0xef, 0xd1, 0xdd, 0x71, 0x7c, 0x86, 0xe7, 0x9f, 0x78, 0xa9, 0xe4, 0xba, - 0xa0, 0x5c, 0x11, 0xc5, 0x04, 0x9f, 0xb3, 0x54, 0x12, 0x59, 0x63, 0x0c, 0x1d, 0x4e, 0x0a, 0xf7, - 0xec, 0x12, 0x13, 0xe3, 0x11, 0xf4, 0x2a, 0x2a, 0x4b, 0x26, 0xb8, 0x69, 0x3a, 0x48, 0x9a, 0xf4, - 0x43, 0x6b, 0x84, 0xc6, 0x17, 0x70, 0xb8, 0xe3, 0x75, 0xb9, 0x14, 0x2b, 0xba, 0x9f, 0xd3, 0xf4, - 0x27, 0xba, 0xd9, 0x04, 0xe8, 0x76, 0x13, 0xa0, 0xbb, 0x4d, 0x80, 0x7e, 0x6d, 0x03, 0xef, 0x76, - 0x1b, 0x78, 0xbf, 0xb7, 0x81, 0x07, 0x21, 0x13, 0x8f, 0x2f, 0x39, 0xf5, 0xcf, 0x4d, 0xb8, 0xd0, - 0xf0, 0x02, 0x7d, 0xbf, 0xc8, 0x76, 0x05, 0x4c, 0x7f, 0xd8, 0x3c, 0xa7, 0x4b, 0x25, 0x64, 0xbc, - 0xba, 0x22, 0x8a, 0xc4, 0x8c, 0x2b, 0x2a, 0x39, 0xc9, 0x63, 0x93, 0x19, 0xc7, 0x8c, 0xf2, 0x87, - 0x7f, 0x9d, 0x76, 0x0d, 0xf6, 0xfe, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x52, 0xfc, 0xa6, 0x58, - 0xff, 0x03, 0x00, 0x00, + // 532 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x4f, 0x6b, 0x13, 0x41, + 0x14, 0xdf, 0x69, 0xd2, 0xfc, 0x79, 0x1b, 0x41, 0x86, 0x22, 0x41, 0xc8, 0x76, 0x8d, 0x07, 0x57, + 0x85, 0x5d, 0x52, 0x2f, 0x5e, 0x93, 0x28, 0x44, 0xac, 0x18, 0xb6, 0xda, 0x83, 0x97, 0x30, 0x49, + 0x86, 0x30, 0x74, 0x33, 0xb3, 0xcc, 0x4e, 0x02, 0xf9, 0x16, 0x7e, 0x0e, 0x2f, 0x7e, 0x8d, 0x5e, + 0x84, 0x1e, 0x3d, 0x49, 0x49, 0xbe, 0x88, 0xcc, 0x9f, 0x24, 0xb5, 0x87, 0x96, 0x7a, 0x7b, 0xf3, + 0xfb, 0xf7, 0xde, 0xcb, 0x4c, 0x16, 0x5e, 0x89, 0x9c, 0x72, 0x45, 0x33, 0x3a, 0xa7, 0x4a, 0xae, + 0x92, 0x5c, 0x0a, 0x25, 0x92, 0x89, 0x98, 0xcf, 0x05, 0x4f, 0x96, 0x1d, 0x57, 0xc5, 0x06, 0xc6, + 0xad, 0x7f, 0xb4, 0x16, 0x8c, 0x9d, 0x62, 0xd9, 0x79, 0x7a, 0x34, 0x13, 0x33, 0x61, 0x03, 0x74, + 0x65, 0xf9, 0xf6, 0xf5, 0x01, 0xd4, 0xba, 0x7c, 0x75, 0x4e, 0xb2, 0x05, 0xc5, 0xcf, 0xa1, 0x51, + 0x28, 0xc9, 0xf8, 0x6c, 0xb4, 0xd4, 0xe7, 0x26, 0x0a, 0x51, 0x54, 0x1f, 0x78, 0xa9, 0x6f, 0x51, + 0x2b, 0x3a, 0x06, 0x18, 0x0b, 0x91, 0x39, 0xc9, 0x41, 0x88, 0xa2, 0xda, 0xc0, 0x4b, 0xeb, 0x1a, + 0xb3, 0x82, 0x16, 0xd4, 0x19, 0x57, 0x8e, 0x2f, 0x85, 0x28, 0x2a, 0x0d, 0xbc, 0xb4, 0xc6, 0xb8, + 0xda, 0x35, 0x99, 0x8a, 0xc5, 0x38, 0xa3, 0x4e, 0x51, 0x0e, 0x51, 0x84, 0x74, 0x13, 0x8b, 0x5a, + 0xd1, 0x29, 0xf8, 0x44, 0x4a, 0xb2, 0x72, 0x9a, 0xc3, 0x10, 0x45, 0xfe, 0xc9, 0xcb, 0xf8, 0xce, + 0x0d, 0xe3, 0xae, 0x76, 0x18, 0xff, 0xc0, 0x4b, 0x81, 0xec, 0x4e, 0x78, 0x08, 0x8d, 0x8b, 0x65, + 0xc6, 0x8a, 0xed, 0x50, 0x15, 0x13, 0xf7, 0xfa, 0x9e, 0xb8, 0x8f, 0xd4, 0xda, 0x4f, 0x59, 0xa1, + 0xf4, 0x7c, 0x36, 0xc2, 0x26, 0x3e, 0x03, 0x7f, 0xbc, 0x52, 0xb4, 0x70, 0x81, 0xd5, 0x10, 0x45, + 0x0d, 0xdd, 0xd4, 0x80, 0x46, 0xd2, 0xab, 0xc2, 0xa1, 0x21, 0xdb, 0x67, 0x00, 0xfb, 0xc9, 0xf0, + 0x7b, 0xa8, 0x18, 0xb8, 0x68, 0xa2, 0xb0, 0x14, 0xf9, 0x27, 0x2f, 0xee, 0x5b, 0xca, 0x5d, 0x4e, + 0xaf, 0x7c, 0xf9, 0xe7, 0xd8, 0x4b, 0x9d, 0xb9, 0xfd, 0x15, 0x1a, 0x37, 0xe7, 0x7b, 0x70, 0xec, + 0xd6, 0x7c, 0x2b, 0x96, 0x40, 0x6d, 0xcb, 0xe0, 0xc7, 0x50, 0xba, 0xa0, 0x2b, 0xfb, 0x08, 0x52, + 0x5d, 0xe2, 0xbe, 0x5b, 0xc9, 0xdc, 0xfa, 0x83, 0x47, 0x77, 0x3f, 0xc7, 0x2f, 0x04, 0x47, 0x1f, + 0x78, 0xa1, 0xe4, 0x62, 0x4e, 0xb9, 0x22, 0x8a, 0x09, 0x7e, 0x36, 0x11, 0x39, 0xc5, 0x18, 0xca, + 0x9c, 0xcc, 0xdd, 0xab, 0x4b, 0x4d, 0x8d, 0x9b, 0x50, 0x5d, 0x52, 0x59, 0x30, 0xc1, 0x4d, 0xcf, + 0x7a, 0xba, 0x3d, 0xe2, 0x4f, 0x00, 0x44, 0x29, 0xc9, 0xc6, 0x0b, 0x45, 0x8b, 0x66, 0xe9, 0x7f, + 0x96, 0xbe, 0x11, 0x80, 0xdf, 0x42, 0x73, 0x2a, 0x45, 0x9e, 0xd3, 0xe9, 0x68, 0x8f, 0x8e, 0x26, + 0x62, 0xc1, 0x95, 0x79, 0xa1, 0x8f, 0xd2, 0x27, 0x8e, 0xef, 0xee, 0xe8, 0xbe, 0x66, 0x7b, 0x3f, + 0xd1, 0xe5, 0x3a, 0x40, 0x57, 0xeb, 0x00, 0x5d, 0xaf, 0x03, 0xf4, 0x7d, 0x13, 0x78, 0x57, 0x9b, + 0xc0, 0xfb, 0xbd, 0x09, 0x3c, 0x08, 0x99, 0xb8, 0x7b, 0xa2, 0x9e, 0xdf, 0x37, 0xe5, 0x50, 0xc3, + 0x43, 0xf4, 0xed, 0xdd, 0xec, 0xb6, 0x81, 0xe9, 0xbf, 0x7b, 0x96, 0xd1, 0x89, 0x12, 0x32, 0xc9, + 0xa7, 0x44, 0x91, 0x84, 0x71, 0x45, 0x25, 0x27, 0x59, 0x62, 0x4e, 0x26, 0x71, 0x46, 0xf9, 0xfe, + 0xab, 0xf0, 0xe3, 0xa0, 0xf5, 0x39, 0xa7, 0xfc, 0xcb, 0x2e, 0xc3, 0xa4, 0xc7, 0xb6, 0x53, 0x7c, + 0xde, 0x19, 0x57, 0x8c, 0xe7, 0xcd, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x04, 0x1b, 0xbb, 0x73, + 0x5d, 0x04, 0x00, 0x00, } func (m *AnyValue) Marshal() (dAtA []byte, err error) { @@ -758,43 +716,6 @@ func (m *KeyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *InstrumentationLibrary) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *InstrumentationLibrary) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *InstrumentationLibrary) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Version) > 0 { - i -= len(m.Version) - copy(dAtA[i:], m.Version) - i = encodeVarintCommon(dAtA, i, uint64(len(m.Version))) - i-- - dAtA[i] = 0x12 - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintCommon(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - func (m *InstrumentationScope) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -815,6 +736,25 @@ func (m *InstrumentationScope) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.DroppedAttributesCount != 0 { + i = encodeVarintCommon(dAtA, i, uint64(m.DroppedAttributesCount)) + i-- + dAtA[i] = 0x20 + } + if len(m.Attributes) > 0 { + for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCommon(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } if len(m.Version) > 0 { i -= len(m.Version) copy(dAtA[i:], m.Version) @@ -973,7 +913,7 @@ func (m *KeyValue) Size() (n int) { return n } -func (m *InstrumentationLibrary) Size() (n int) { +func (m *InstrumentationScope) Size() (n int) { if m == nil { return 0 } @@ -987,22 +927,14 @@ func (m *InstrumentationLibrary) Size() (n int) { if l > 0 { n += 1 + l + sovCommon(uint64(l)) } - return n -} - -func (m *InstrumentationScope) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovCommon(uint64(l)) + if len(m.Attributes) > 0 { + for _, e := range m.Attributes { + l = e.Size() + n += 1 + l + sovCommon(uint64(l)) + } } - l = len(m.Version) - if l > 0 { - n += 1 + l + sovCommon(uint64(l)) + if m.DroppedAttributesCount != 0 { + n += 1 + sovCommon(uint64(m.DroppedAttributesCount)) } return n } @@ -1533,7 +1465,7 @@ func (m *KeyValue) Unmarshal(dAtA []byte) error { } return nil } -func (m *InstrumentationLibrary) Unmarshal(dAtA []byte) error { +func (m *InstrumentationScope) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1556,10 +1488,10 @@ func (m *InstrumentationLibrary) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: InstrumentationLibrary: wiretype end group for non-group") + return fmt.Errorf("proto: InstrumentationScope: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: InstrumentationLibrary: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: InstrumentationScope: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -1626,61 +1558,11 @@ func (m *InstrumentationLibrary) Unmarshal(dAtA []byte) error { } m.Version = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCommon(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCommon - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *InstrumentationScope) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCommon - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: InstrumentationScope: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: InstrumentationScope: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCommon @@ -1690,29 +1572,31 @@ func (m *InstrumentationScope) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthCommon } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthCommon } if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Attributes = append(m.Attributes, KeyValue{}) + if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DroppedAttributesCount", wireType) } - var stringLen uint64 + m.DroppedAttributesCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCommon @@ -1722,24 +1606,11 @@ func (m *InstrumentationScope) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.DroppedAttributesCount |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthCommon - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCommon - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Version = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCommon(dAtA[iNdEx:]) diff --git a/pdata/internal/data/protogen/logs/v1/logs.pb.go b/pdata/internal/data/protogen/logs/v1/logs.pb.go index 2e54d016416..b1c8a16ce4c 100644 --- a/pdata/internal/data/protogen/logs/v1/logs.pb.go +++ b/pdata/internal/data/protogen/logs/v1/logs.pb.go @@ -217,34 +217,6 @@ type ResourceLogs struct { Resource v1.Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource"` // A list of ScopeLogs that originate from a resource. ScopeLogs []*ScopeLogs `protobuf:"bytes,2,rep,name=scope_logs,json=scopeLogs,proto3" json:"scope_logs,omitempty"` - // A list of InstrumentationLibraryLogs that originate from a resource. - // This field is deprecated and will be removed after grace period expires on June 15, 2022. - // - // During the grace period the following rules SHOULD be followed: - // - // For Binary Protobufs - // ==================== - // Binary Protobuf senders SHOULD NOT set instrumentation_library_logs. Instead - // scope_logs SHOULD be set. - // - // Binary Protobuf receivers SHOULD check if instrumentation_library_logs is set - // and scope_logs is not set then the value in instrumentation_library_logs - // SHOULD be used instead by converting InstrumentationLibraryLogs into ScopeLogs. - // If scope_logs is set then instrumentation_library_logs SHOULD be ignored. - // - // For JSON - // ======== - // JSON senders that set instrumentation_library_logs field MAY also set - // scope_logs to carry the same logs, essentially double-publishing the same data. - // Such double-publishing MAY be controlled by a user-settable option. - // If double-publishing is not used then the senders SHOULD set scope_logs and - // SHOULD NOT set instrumentation_library_logs. - // - // JSON receivers SHOULD check if instrumentation_library_logs is set and - // scope_logs is not set then the value in instrumentation_library_logs - // SHOULD be used instead by converting InstrumentationLibraryLogs into ScopeLogs. - // If scope_logs is set then instrumentation_library_logs field SHOULD be ignored. - InstrumentationLibraryLogs []*InstrumentationLibraryLogs `protobuf:"bytes,1000,rep,name=instrumentation_library_logs,json=instrumentationLibraryLogs,proto3" json:"instrumentation_library_logs,omitempty"` // Deprecated: Do not use. // 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. SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` @@ -297,14 +269,6 @@ func (m *ResourceLogs) GetScopeLogs() []*ScopeLogs { return nil } -// Deprecated: Do not use. -func (m *ResourceLogs) GetInstrumentationLibraryLogs() []*InstrumentationLibraryLogs { - if m != nil { - return m.InstrumentationLibraryLogs - } - return nil -} - func (m *ResourceLogs) GetSchemaUrl() string { if m != nil { return m.SchemaUrl @@ -378,77 +342,6 @@ func (m *ScopeLogs) GetSchemaUrl() string { return "" } -// A collection of Logs produced by an InstrumentationLibrary. -// InstrumentationLibraryLogs is wire-compatible with ScopeLogs for binary -// Protobuf format. -// This message is deprecated and will be removed on June 15, 2022. -// -// Deprecated: Do not use. -type InstrumentationLibraryLogs struct { - // The instrumentation library information for the logs in this message. - // Semantically when InstrumentationLibrary isn't set, it is equivalent with - // an empty instrumentation library name (unknown). - InstrumentationLibrary v11.InstrumentationLibrary `protobuf:"bytes,1,opt,name=instrumentation_library,json=instrumentationLibrary,proto3" json:"instrumentation_library"` - // A list of logs that originate from an instrumentation library. - LogRecords []*LogRecord `protobuf:"bytes,2,rep,name=log_records,json=logRecords,proto3" json:"log_records,omitempty"` - // This schema_url applies to all logs in the "logs" field. - SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` -} - -func (m *InstrumentationLibraryLogs) Reset() { *m = InstrumentationLibraryLogs{} } -func (m *InstrumentationLibraryLogs) String() string { return proto.CompactTextString(m) } -func (*InstrumentationLibraryLogs) ProtoMessage() {} -func (*InstrumentationLibraryLogs) Descriptor() ([]byte, []int) { - return fileDescriptor_d1c030a3ec7e961e, []int{3} -} -func (m *InstrumentationLibraryLogs) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *InstrumentationLibraryLogs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_InstrumentationLibraryLogs.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *InstrumentationLibraryLogs) XXX_Merge(src proto.Message) { - xxx_messageInfo_InstrumentationLibraryLogs.Merge(m, src) -} -func (m *InstrumentationLibraryLogs) XXX_Size() int { - return m.Size() -} -func (m *InstrumentationLibraryLogs) XXX_DiscardUnknown() { - xxx_messageInfo_InstrumentationLibraryLogs.DiscardUnknown(m) -} - -var xxx_messageInfo_InstrumentationLibraryLogs proto.InternalMessageInfo - -func (m *InstrumentationLibraryLogs) GetInstrumentationLibrary() v11.InstrumentationLibrary { - if m != nil { - return m.InstrumentationLibrary - } - return v11.InstrumentationLibrary{} -} - -func (m *InstrumentationLibraryLogs) GetLogRecords() []*LogRecord { - if m != nil { - return m.LogRecords - } - return nil -} - -func (m *InstrumentationLibraryLogs) GetSchemaUrl() string { - if m != nil { - return m.SchemaUrl - } - return "" -} - // A log record according to OpenTelemetry Log Data Model: // https://github.com/open-telemetry/oteps/blob/main/text/logs/0097-log-data-model.md type LogRecord struct { @@ -509,7 +402,7 @@ func (m *LogRecord) Reset() { *m = LogRecord{} } func (m *LogRecord) String() string { return proto.CompactTextString(m) } func (*LogRecord) ProtoMessage() {} func (*LogRecord) Descriptor() ([]byte, []int) { - return fileDescriptor_d1c030a3ec7e961e, []int{4} + return fileDescriptor_d1c030a3ec7e961e, []int{3} } func (m *LogRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -600,7 +493,6 @@ func init() { proto.RegisterType((*LogsData)(nil), "opentelemetry.proto.logs.v1.LogsData") proto.RegisterType((*ResourceLogs)(nil), "opentelemetry.proto.logs.v1.ResourceLogs") proto.RegisterType((*ScopeLogs)(nil), "opentelemetry.proto.logs.v1.ScopeLogs") - proto.RegisterType((*InstrumentationLibraryLogs)(nil), "opentelemetry.proto.logs.v1.InstrumentationLibraryLogs") proto.RegisterType((*LogRecord)(nil), "opentelemetry.proto.logs.v1.LogRecord") } @@ -609,68 +501,65 @@ func init() { } var fileDescriptor_d1c030a3ec7e961e = []byte{ - // 971 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x96, 0x41, 0x73, 0x22, 0x45, - 0x14, 0xc7, 0x33, 0x24, 0x04, 0xe8, 0x10, 0xb6, 0x6d, 0xb3, 0xc9, 0x48, 0x94, 0x50, 0x51, 0x57, - 0x8c, 0x55, 0x50, 0x0b, 0x6c, 0xb9, 0x7a, 0x72, 0x08, 0x43, 0x0a, 0x43, 0x20, 0xd5, 0xc0, 0xea, - 0x6e, 0x59, 0x35, 0x35, 0x40, 0x8b, 0x53, 0x35, 0x4c, 0x53, 0x3d, 0x4d, 0x2a, 0x5c, 0x3c, 0x79, - 0xf1, 0xe6, 0x57, 0xb2, 0xf4, 0xb0, 0xc7, 0x3d, 0x5a, 0x1e, 0xb6, 0xac, 0xe4, 0xe2, 0xa7, 0x50, - 0xab, 0x7b, 0x06, 0x04, 0x9c, 0x21, 0xe6, 0xb2, 0x27, 0xba, 0xdf, 0xef, 0xbd, 0x7f, 0xff, 0x5f, - 0x77, 0x4f, 0x17, 0xe0, 0x11, 0x1d, 0x13, 0x87, 0x13, 0x9b, 0x8c, 0x08, 0x67, 0xd3, 0xc2, 0x98, - 0x51, 0x4e, 0x0b, 0x36, 0x1d, 0xba, 0x85, 0xab, 0xc7, 0xf2, 0x37, 0x2f, 0x43, 0xe8, 0x70, 0x29, - 0xcf, 0x0b, 0xe6, 0x25, 0xbf, 0x7a, 0x9c, 0xde, 0x1b, 0xd2, 0x21, 0xf5, 0x4a, 0xc5, 0xc8, 0xa3, - 0xe9, 0x93, 0x20, 0xe9, 0x3e, 0x1d, 0x8d, 0xa8, 0x23, 0xc4, 0xbd, 0x91, 0x9f, 0x9b, 0x0f, 0xca, - 0x65, 0xc4, 0xa5, 0x13, 0xd6, 0x27, 0x22, 0x7b, 0x36, 0xf6, 0xf2, 0x8f, 0x5f, 0x80, 0x78, 0x83, - 0x0e, 0xdd, 0xaa, 0xc9, 0x4d, 0xd4, 0x04, 0xbb, 0x33, 0x6a, 0x08, 0x47, 0xaa, 0x92, 0xdd, 0xcc, - 0xed, 0x14, 0x3f, 0xce, 0xaf, 0xb1, 0x9c, 0xc7, 0x7e, 0x85, 0x50, 0xc1, 0x49, 0xb6, 0x30, 0x3b, - 0xfe, 0x39, 0x02, 0x92, 0x8b, 0x18, 0x9d, 0x83, 0xf8, 0x2c, 0x41, 0x55, 0xb2, 0x4a, 0xa8, 0xf6, - 0xdc, 0xe3, 0x82, 0x7e, 0x65, 0xeb, 0xe5, 0xeb, 0xa3, 0x0d, 0x3c, 0x17, 0x40, 0x3a, 0x00, 0x6e, - 0x9f, 0x8e, 0x7d, 0xab, 0x11, 0x69, 0xf5, 0xd1, 0x5a, 0xab, 0x6d, 0x91, 0x2e, 0x7d, 0x26, 0xdc, - 0xd9, 0x10, 0x7d, 0x0f, 0xde, 0xb5, 0x1c, 0x97, 0xb3, 0xc9, 0x88, 0x38, 0xdc, 0xe4, 0x16, 0x75, - 0x0c, 0xdb, 0xea, 0x31, 0x93, 0x4d, 0x3d, 0xe1, 0x3f, 0x63, 0x52, 0xf9, 0xd3, 0xb5, 0xca, 0xf5, - 0x65, 0x85, 0x86, 0x27, 0x20, 0xf4, 0x2b, 0x11, 0x55, 0xc1, 0x69, 0x2b, 0x94, 0xa3, 0xf7, 0x44, - 0x1b, 0xdf, 0x91, 0x91, 0x69, 0x4c, 0x98, 0xad, 0x6e, 0x66, 0x95, 0x5c, 0x42, 0xd8, 0x13, 0x91, - 0x2e, 0xb3, 0x8f, 0x7f, 0x55, 0x40, 0x62, 0xee, 0x1b, 0xb5, 0x40, 0x54, 0x3a, 0xf7, 0x77, 0xaf, - 0x14, 0x68, 0xca, 0xbf, 0x0f, 0xff, 0xb5, 0x25, 0x75, 0xfc, 0x7d, 0xf4, 0x74, 0xd0, 0x19, 0xd8, - 0xb1, 0xe9, 0xd0, 0x60, 0xa4, 0x4f, 0xd9, 0xe0, 0xff, 0xed, 0x62, 0x83, 0x0e, 0xb1, 0x4c, 0xc7, - 0xc0, 0x9e, 0x0d, 0xef, 0x6c, 0xe3, 0x2f, 0x05, 0xa4, 0xc3, 0x37, 0x09, 0x71, 0x70, 0x10, 0x72, - 0x08, 0x7e, 0xa7, 0x4f, 0xee, 0xd7, 0xa9, 0xaf, 0xed, 0xf7, 0xba, 0x1f, 0xbc, 0xfd, 0x6f, 0xaa, - 0xf9, 0xcf, 0x23, 0xaa, 0x72, 0xfc, 0x43, 0x14, 0x24, 0xe6, 0xc5, 0xe8, 0x03, 0x90, 0xe2, 0xd6, - 0x88, 0x18, 0x13, 0xc7, 0xba, 0x36, 0x1c, 0xd3, 0xa1, 0xb2, 0xcd, 0x6d, 0x9c, 0x14, 0xd1, 0xae, - 0x63, 0x5d, 0x37, 0x4d, 0x87, 0xa2, 0x27, 0xe0, 0x80, 0xf6, 0x5c, 0xc2, 0xae, 0xc8, 0xc0, 0x58, - 0x49, 0xdf, 0x91, 0xe9, 0x7b, 0x33, 0xdc, 0x59, 0x2c, 0xeb, 0x80, 0x07, 0x2e, 0xb9, 0x22, 0xcc, - 0xe2, 0x53, 0xc3, 0x99, 0x8c, 0x7a, 0x84, 0xa9, 0x91, 0xac, 0x92, 0x4b, 0x15, 0x3f, 0x59, 0xff, - 0x75, 0xf8, 0x35, 0x4d, 0x59, 0x82, 0x53, 0xee, 0xd2, 0x1c, 0xbd, 0x0f, 0x76, 0xe7, 0xaa, 0x9c, - 0x5c, 0x73, 0xbf, 0xcd, 0xe4, 0x2c, 0xd8, 0x21, 0xd7, 0x1c, 0x69, 0x60, 0xab, 0x47, 0x07, 0x53, - 0x35, 0x2a, 0x0f, 0xed, 0xa3, 0x3b, 0x0e, 0x4d, 0x73, 0xa6, 0xcf, 0x4c, 0x7b, 0x32, 0xbb, 0x92, - 0xb2, 0x14, 0x5d, 0x00, 0x60, 0x72, 0xce, 0xac, 0xde, 0x84, 0x13, 0x57, 0xdd, 0x96, 0x67, 0x72, - 0x97, 0xd0, 0x39, 0x59, 0x12, 0x5a, 0x10, 0x40, 0x4f, 0x81, 0x3a, 0x60, 0x74, 0x3c, 0x26, 0x03, - 0xe3, 0xdf, 0xa8, 0xd1, 0xa7, 0x13, 0x87, 0xab, 0xb1, 0xac, 0x92, 0xdb, 0xc5, 0xfb, 0x3e, 0xd7, - 0xe6, 0xf8, 0x54, 0x50, 0xb4, 0x07, 0xa2, 0xdf, 0xda, 0xe6, 0xd0, 0x55, 0xe3, 0x59, 0x25, 0x17, - 0xc3, 0xde, 0x04, 0x7d, 0x03, 0xe2, 0x9c, 0x99, 0x7d, 0x62, 0x58, 0x03, 0x35, 0x91, 0x55, 0x72, - 0xc9, 0x8a, 0x26, 0xd6, 0xfc, 0xfd, 0xf5, 0xd1, 0x67, 0x43, 0xba, 0x62, 0xd3, 0x12, 0xaf, 0xb4, - 0x6d, 0x93, 0x3e, 0xa7, 0xac, 0x30, 0x1e, 0x98, 0xdc, 0x2c, 0x58, 0x0e, 0x27, 0xcc, 0x31, 0xed, - 0x82, 0x98, 0xe5, 0x3b, 0x42, 0xa9, 0x5e, 0xc5, 0x31, 0x29, 0x59, 0x1f, 0xa0, 0xe7, 0x20, 0xe6, - 0x8e, 0x4d, 0x47, 0x88, 0x03, 0x29, 0xfe, 0x85, 0x2f, 0xfe, 0xf4, 0xfe, 0xe2, 0xed, 0xb1, 0xe9, - 0xd4, 0xab, 0x78, 0x5b, 0x08, 0xd6, 0x07, 0x5f, 0x6e, 0xc5, 0xb7, 0x60, 0xf4, 0xe4, 0x97, 0x28, - 0x48, 0x2d, 0x1f, 0x34, 0x3a, 0x02, 0x87, 0x6d, 0xfd, 0x99, 0x8e, 0xeb, 0x9d, 0xe7, 0x46, 0xb3, - 0x7b, 0x51, 0xd1, 0xb1, 0xd1, 0x6d, 0xb6, 0x2f, 0xf5, 0xd3, 0x7a, 0xad, 0xae, 0x57, 0xe1, 0x06, - 0x7a, 0x07, 0x3c, 0x5c, 0x4d, 0xe8, 0x60, 0xed, 0x54, 0x87, 0x0a, 0x4a, 0x83, 0xfd, 0x40, 0x54, - 0x84, 0x91, 0x50, 0x56, 0x82, 0x9b, 0xa1, 0xac, 0x0c, 0xb7, 0x82, 0x96, 0xab, 0xea, 0x95, 0xee, - 0x19, 0x8c, 0x06, 0x95, 0x49, 0x54, 0x84, 0xdb, 0xa1, 0xac, 0x04, 0x63, 0xa1, 0xac, 0x0c, 0xe3, - 0x48, 0x05, 0x7b, 0xab, 0xac, 0xde, 0xac, 0xb5, 0x60, 0x22, 0xc8, 0x88, 0x20, 0x45, 0x08, 0xc2, - 0x50, 0x09, 0xee, 0x84, 0xa1, 0x32, 0x4c, 0x06, 0x2d, 0xf5, 0x95, 0x86, 0x9b, 0x70, 0x37, 0xa8, - 0x48, 0x90, 0x22, 0x4c, 0x85, 0xa1, 0x12, 0x7c, 0x10, 0x86, 0xca, 0x10, 0x06, 0x21, 0x1d, 0xe3, - 0x16, 0x86, 0x6f, 0x05, 0x6d, 0x86, 0x44, 0x45, 0x88, 0x42, 0x59, 0x09, 0xbe, 0x1d, 0xca, 0xca, - 0x70, 0x2f, 0x68, 0xb9, 0x9a, 0xd6, 0xd1, 0x1a, 0xf0, 0x61, 0x50, 0x99, 0x44, 0x45, 0xb8, 0x1f, - 0xca, 0x4a, 0xf0, 0x20, 0x94, 0x95, 0xa1, 0x7a, 0xf2, 0x35, 0x48, 0xcd, 0xdf, 0xd2, 0x9a, 0xfc, - 0x2c, 0x8f, 0xc0, 0x61, 0xa3, 0x75, 0x66, 0x60, 0xfd, 0xb4, 0x85, 0xab, 0x46, 0xad, 0xa1, 0x9d, - 0xad, 0x5c, 0xe2, 0x0f, 0x41, 0x76, 0x35, 0x41, 0xde, 0x38, 0x39, 0x6c, 0x1b, 0x17, 0x5a, 0xfb, - 0x1c, 0xfe, 0xad, 0x54, 0x7e, 0x54, 0x5e, 0xde, 0x64, 0x94, 0x57, 0x37, 0x19, 0xe5, 0x8f, 0x9b, - 0x8c, 0xf2, 0xd3, 0x6d, 0x66, 0xe3, 0xd5, 0x6d, 0x66, 0xe3, 0xb7, 0xdb, 0xcc, 0x06, 0xc8, 0x58, - 0x74, 0xdd, 0xfb, 0x59, 0x11, 0xcf, 0xbb, 0x7b, 0x29, 0x42, 0x97, 0xca, 0x8b, 0xca, 0xbd, 0xbf, - 0x57, 0xef, 0xaf, 0xda, 0x90, 0x38, 0xb3, 0x3f, 0x8d, 0xbd, 0x6d, 0x19, 0x29, 0xfd, 0x13, 0x00, - 0x00, 0xff, 0xff, 0x43, 0x73, 0x1b, 0xe8, 0x5a, 0x0a, 0x00, 0x00, + // 928 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x96, 0xdf, 0x6e, 0xe2, 0x46, + 0x14, 0xc6, 0x71, 0x96, 0xbf, 0x13, 0xc2, 0x4e, 0xa7, 0x6c, 0xd6, 0x4d, 0x54, 0x82, 0xd2, 0x76, + 0x4b, 0x53, 0x09, 0x14, 0xa0, 0xd2, 0xf6, 0xae, 0x26, 0x98, 0x88, 0x0d, 0x81, 0x68, 0x80, 0xb4, + 0xbb, 0xaa, 0x64, 0x19, 0x98, 0x52, 0x4b, 0x66, 0x06, 0x8d, 0x07, 0x94, 0xdc, 0xf7, 0x01, 0xfa, + 0x16, 0x95, 0xfa, 0x1a, 0xed, 0xc5, 0xf6, 0x6e, 0x2f, 0xab, 0x5e, 0xac, 0xaa, 0xe4, 0xa6, 0x7d, + 0x8a, 0x56, 0x33, 0x18, 0x4a, 0x90, 0x9d, 0x74, 0xaf, 0x32, 0x73, 0x7e, 0xdf, 0xf9, 0xe6, 0x9c, + 0x1c, 0x7b, 0x30, 0x78, 0xc6, 0xa6, 0x84, 0x0a, 0xe2, 0x92, 0x09, 0x11, 0xfc, 0xba, 0x34, 0xe5, + 0x4c, 0xb0, 0x92, 0xcb, 0xc6, 0x5e, 0x69, 0x7e, 0xac, 0xfe, 0x16, 0x55, 0x08, 0xed, 0xdf, 0xd1, + 0x2d, 0x82, 0x45, 0xc5, 0xe7, 0xc7, 0x7b, 0xd9, 0x31, 0x1b, 0xb3, 0x45, 0xaa, 0x5c, 0x2d, 0xe8, + 0xde, 0x51, 0x90, 0xf5, 0x90, 0x4d, 0x26, 0x8c, 0x4a, 0xf3, 0xc5, 0xca, 0xd7, 0x16, 0x83, 0xb4, + 0x9c, 0x78, 0x6c, 0xc6, 0x87, 0x44, 0xaa, 0x97, 0xeb, 0x85, 0xfe, 0xf0, 0x15, 0x48, 0xb6, 0xd8, + 0xd8, 0xab, 0xdb, 0xc2, 0x46, 0x6d, 0xb0, 0xb3, 0xa4, 0x96, 0xac, 0x48, 0xd7, 0xf2, 0x8f, 0x0a, + 0xdb, 0xe5, 0xcf, 0x8a, 0xf7, 0x94, 0x5c, 0xc4, 0x7e, 0x86, 0x74, 0xc1, 0x69, 0xbe, 0xb6, 0x3b, + 0xfc, 0x4d, 0x03, 0xe9, 0x75, 0x8c, 0xce, 0x40, 0x72, 0x29, 0xd0, 0xb5, 0xbc, 0x16, 0xea, 0xbd, + 0xaa, 0x71, 0xcd, 0xbf, 0x16, 0x7d, 0xfd, 0xf6, 0x20, 0x82, 0x57, 0x06, 0xc8, 0x04, 0xc0, 0x1b, + 0xb2, 0xa9, 0x5f, 0xea, 0x96, 0x2a, 0xf5, 0xd9, 0xbd, 0xa5, 0x76, 0xa5, 0x5c, 0xd5, 0x99, 0xf2, + 0x96, 0x4b, 0xf4, 0xa1, 0xb4, 0xf9, 0x9e, 0x4c, 0x6c, 0x6b, 0xc6, 0x5d, 0xfd, 0x51, 0x5e, 0x2b, + 0xa4, 0x24, 0x96, 0x91, 0x3e, 0x77, 0x5f, 0xc4, 0x93, 0x7f, 0x25, 0xe0, 0xdf, 0x89, 0xc3, 0x5f, + 0x35, 0x90, 0x5a, 0xe5, 0xa3, 0x0e, 0x88, 0x29, 0x07, 0xbf, 0x8b, 0x4a, 0xe0, 0xb1, 0xfe, 0x5c, + 0xe6, 0xc7, 0xc5, 0x26, 0xf5, 0x04, 0x9f, 0x4d, 0x08, 0x15, 0xb6, 0x70, 0x18, 0x55, 0x3e, 0x7e, + 0x3f, 0x0b, 0x1f, 0x74, 0x0a, 0xb6, 0x5d, 0x36, 0xb6, 0x38, 0x19, 0x32, 0x3e, 0xfa, 0x7f, 0xdd, + 0xb4, 0xd8, 0x18, 0x2b, 0x39, 0x06, 0xee, 0x72, 0xf9, 0x50, 0x3b, 0x87, 0x3f, 0xc4, 0x40, 0x6a, + 0x95, 0x88, 0x3e, 0x06, 0x19, 0xe1, 0x4c, 0x88, 0x35, 0xa3, 0xce, 0x95, 0x45, 0x6d, 0xca, 0x54, + 0x3f, 0x71, 0x9c, 0x96, 0xd1, 0x3e, 0x75, 0xae, 0xda, 0x36, 0x65, 0xe8, 0x0b, 0xf0, 0x94, 0x0d, + 0x3c, 0xc2, 0xe7, 0x64, 0x64, 0x6d, 0xc8, 0xb7, 0x95, 0x3c, 0xbb, 0xc4, 0xbd, 0xf5, 0xb4, 0x1e, + 0x78, 0xec, 0x91, 0x39, 0xe1, 0x8e, 0xb8, 0xb6, 0xe8, 0x6c, 0x32, 0x20, 0x5c, 0xdf, 0xca, 0x6b, + 0x85, 0x4c, 0xf9, 0xf3, 0xfb, 0x87, 0xe4, 0xe7, 0xb4, 0x55, 0x0a, 0xce, 0x78, 0x77, 0xf6, 0xe8, + 0x23, 0xb0, 0xb3, 0x72, 0x15, 0xe4, 0x4a, 0xf8, 0x2d, 0xa6, 0x97, 0xc1, 0x1e, 0xb9, 0x12, 0xc8, + 0x00, 0xd1, 0x01, 0x1b, 0x5d, 0xeb, 0x31, 0x35, 0x9d, 0x4f, 0x1f, 0x98, 0x8e, 0x41, 0xaf, 0x2f, + 0x6d, 0x77, 0xb6, 0x9c, 0x88, 0x4a, 0x45, 0xe7, 0x00, 0xd8, 0x42, 0x70, 0x67, 0x30, 0x13, 0xc4, + 0xd3, 0xe3, 0x6a, 0x1e, 0x0f, 0x19, 0x9d, 0x91, 0x3b, 0x46, 0x6b, 0x06, 0xe8, 0x39, 0xd0, 0x47, + 0x9c, 0x4d, 0xa7, 0x64, 0x64, 0xfd, 0x17, 0xb5, 0x86, 0x6c, 0x46, 0x85, 0x9e, 0xc8, 0x6b, 0x85, + 0x1d, 0xbc, 0xeb, 0x73, 0x63, 0x85, 0x4f, 0x24, 0x45, 0x59, 0x10, 0xfb, 0xce, 0xb5, 0xc7, 0x9e, + 0x9e, 0xcc, 0x6b, 0x85, 0x04, 0x5e, 0x6c, 0xd0, 0xb7, 0x20, 0x29, 0xb8, 0x3d, 0x24, 0x96, 0x33, + 0xd2, 0x53, 0x79, 0xad, 0x90, 0xae, 0x19, 0xf2, 0xcc, 0x3f, 0xde, 0x1e, 0x7c, 0x39, 0x66, 0x1b, + 0x65, 0x3a, 0xf2, 0xb2, 0x70, 0x5d, 0x32, 0x14, 0x8c, 0x97, 0xa6, 0x23, 0x5b, 0xd8, 0x25, 0x87, + 0x0a, 0xc2, 0xa9, 0xed, 0x96, 0xe4, 0xae, 0xd8, 0x93, 0x4e, 0xcd, 0x3a, 0x4e, 0x28, 0xcb, 0xe6, + 0x08, 0xbd, 0x04, 0x09, 0x6f, 0x6a, 0x53, 0x69, 0x0e, 0x94, 0xf9, 0x57, 0xbe, 0xf9, 0xf3, 0x77, + 0x37, 0xef, 0x4e, 0x6d, 0xda, 0xac, 0xe3, 0xb8, 0x34, 0x6c, 0x8e, 0x5e, 0x44, 0x93, 0x51, 0x18, + 0x3b, 0xfa, 0x25, 0x06, 0x32, 0x77, 0x07, 0x8d, 0x0e, 0xc0, 0x7e, 0xd7, 0xbc, 0x34, 0x71, 0xb3, + 0xf7, 0xd2, 0x6a, 0xf7, 0xcf, 0x6b, 0x26, 0xb6, 0xfa, 0xed, 0xee, 0x85, 0x79, 0xd2, 0x6c, 0x34, + 0xcd, 0x3a, 0x8c, 0xa0, 0x0f, 0xc0, 0x93, 0x4d, 0x41, 0x0f, 0x1b, 0x27, 0x26, 0xd4, 0xd0, 0x1e, + 0xd8, 0x0d, 0x44, 0x65, 0xb8, 0x15, 0xca, 0x2a, 0xf0, 0x51, 0x28, 0xab, 0xc2, 0x68, 0xd0, 0x71, + 0x75, 0xb3, 0xd6, 0x3f, 0x85, 0xb1, 0xa0, 0x34, 0x85, 0xca, 0x30, 0x1e, 0xca, 0x2a, 0x30, 0x11, + 0xca, 0xaa, 0x30, 0x89, 0x74, 0x90, 0xdd, 0x64, 0xcd, 0x76, 0xa3, 0x03, 0x53, 0x41, 0x85, 0x48, + 0x52, 0x86, 0x20, 0x0c, 0x55, 0xe0, 0x76, 0x18, 0xaa, 0xc2, 0x74, 0xd0, 0x51, 0x5f, 0x1b, 0xb8, + 0x0d, 0x77, 0x82, 0x92, 0x24, 0x29, 0xc3, 0x4c, 0x18, 0xaa, 0xc0, 0xc7, 0x61, 0xa8, 0x0a, 0x61, + 0x10, 0x32, 0x31, 0xee, 0x60, 0xf8, 0x5e, 0xd0, 0x3f, 0x43, 0xa1, 0x32, 0x44, 0xa1, 0xac, 0x02, + 0xdf, 0x0f, 0x65, 0x55, 0x98, 0x0d, 0x3a, 0xae, 0x61, 0xf4, 0x8c, 0x16, 0x7c, 0x12, 0x94, 0xa6, + 0x50, 0x19, 0xee, 0x86, 0xb2, 0x0a, 0x7c, 0x1a, 0xca, 0xaa, 0x50, 0x3f, 0xfa, 0x06, 0x64, 0x56, + 0x77, 0x69, 0x43, 0xbd, 0x96, 0x07, 0x60, 0xbf, 0xd5, 0x39, 0xb5, 0xb0, 0x79, 0xd2, 0xc1, 0x75, + 0xab, 0xd1, 0x32, 0x4e, 0x37, 0x1e, 0xe2, 0x4f, 0x40, 0x7e, 0x53, 0xa0, 0x9e, 0x38, 0xb5, 0xec, + 0x5a, 0xe7, 0x46, 0xf7, 0x0c, 0xfe, 0xa3, 0xd5, 0x7e, 0xd2, 0x5e, 0xdf, 0xe4, 0xb4, 0x37, 0x37, + 0x39, 0xed, 0xcf, 0x9b, 0x9c, 0xf6, 0xe3, 0x6d, 0x2e, 0xf2, 0xe6, 0x36, 0x17, 0xf9, 0xfd, 0x36, + 0x17, 0x01, 0x39, 0x87, 0xdd, 0x77, 0x7f, 0xd6, 0xe4, 0xf5, 0xee, 0x5d, 0xc8, 0xd0, 0x85, 0xf6, + 0xaa, 0xf6, 0xce, 0xef, 0xeb, 0xe2, 0x8b, 0x61, 0x4c, 0xe8, 0xf2, 0xdb, 0xe5, 0xe7, 0xad, 0xfd, + 0xce, 0x94, 0xd0, 0xde, 0xca, 0x41, 0x79, 0xcb, 0x5f, 0x1f, 0xaf, 0x78, 0x79, 0x3c, 0x88, 0x2b, + 0x7d, 0xe5, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbd, 0x92, 0x1b, 0x9e, 0xff, 0x08, 0x00, 0x00, } func (m *LogsData) Marshal() (dAtA []byte, err error) { @@ -730,22 +619,6 @@ func (m *ResourceLogs) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if len(m.InstrumentationLibraryLogs) > 0 { - for iNdEx := len(m.InstrumentationLibraryLogs) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.InstrumentationLibraryLogs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLogs(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3e - i-- - dAtA[i] = 0xc2 - } - } if len(m.SchemaUrl) > 0 { i -= len(m.SchemaUrl) copy(dAtA[i:], m.SchemaUrl) @@ -834,60 +707,6 @@ func (m *ScopeLogs) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *InstrumentationLibraryLogs) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *InstrumentationLibraryLogs) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *InstrumentationLibraryLogs) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.SchemaUrl) > 0 { - i -= len(m.SchemaUrl) - copy(dAtA[i:], m.SchemaUrl) - i = encodeVarintLogs(dAtA, i, uint64(len(m.SchemaUrl))) - i-- - dAtA[i] = 0x1a - } - if len(m.LogRecords) > 0 { - for iNdEx := len(m.LogRecords) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.LogRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLogs(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - { - size, err := m.InstrumentationLibrary.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLogs(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - func (m *LogRecord) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1034,12 +853,6 @@ func (m *ResourceLogs) Size() (n int) { if l > 0 { n += 1 + l + sovLogs(uint64(l)) } - if len(m.InstrumentationLibraryLogs) > 0 { - for _, e := range m.InstrumentationLibraryLogs { - l = e.Size() - n += 2 + l + sovLogs(uint64(l)) - } - } return n } @@ -1064,27 +877,6 @@ func (m *ScopeLogs) Size() (n int) { return n } -func (m *InstrumentationLibraryLogs) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.InstrumentationLibrary.Size() - n += 1 + l + sovLogs(uint64(l)) - if len(m.LogRecords) > 0 { - for _, e := range m.LogRecords { - l = e.Size() - n += 1 + l + sovLogs(uint64(l)) - } - } - l = len(m.SchemaUrl) - if l > 0 { - n += 1 + l + sovLogs(uint64(l)) - } - return n -} - func (m *LogRecord) Size() (n int) { if m == nil { return 0 @@ -1343,40 +1135,6 @@ func (m *ResourceLogs) Unmarshal(dAtA []byte) error { } m.SchemaUrl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 1000: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InstrumentationLibraryLogs", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLogs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLogs - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLogs - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.InstrumentationLibraryLogs = append(m.InstrumentationLibraryLogs, &InstrumentationLibraryLogs{}) - if err := m.InstrumentationLibraryLogs[len(m.InstrumentationLibraryLogs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLogs(dAtA[iNdEx:]) @@ -1547,155 +1305,6 @@ func (m *ScopeLogs) Unmarshal(dAtA []byte) error { } return nil } -func (m *InstrumentationLibraryLogs) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLogs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: InstrumentationLibraryLogs: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: InstrumentationLibraryLogs: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InstrumentationLibrary", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLogs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLogs - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLogs - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.InstrumentationLibrary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LogRecords", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLogs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLogs - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLogs - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.LogRecords = append(m.LogRecords, &LogRecord{}) - if err := m.LogRecords[len(m.LogRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SchemaUrl", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLogs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthLogs - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLogs - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SchemaUrl = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipLogs(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthLogs - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *LogRecord) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/pdata/internal/data/protogen/metrics/v1/metrics.pb.go b/pdata/internal/data/protogen/metrics/v1/metrics.pb.go index 5c86a43cc4b..6cbc31afdcb 100644 --- a/pdata/internal/data/protogen/metrics/v1/metrics.pb.go +++ b/pdata/internal/data/protogen/metrics/v1/metrics.pb.go @@ -220,34 +220,6 @@ type ResourceMetrics struct { Resource v1.Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource"` // A list of metrics that originate from a resource. ScopeMetrics []*ScopeMetrics `protobuf:"bytes,2,rep,name=scope_metrics,json=scopeMetrics,proto3" json:"scope_metrics,omitempty"` - // A list of InstrumentationLibraryMetrics that originate from a resource. - // This field is deprecated and will be removed after grace period expires on June 15, 2022. - // - // During the grace period the following rules SHOULD be followed: - // - // For Binary Protobufs - // ==================== - // Binary Protobuf senders SHOULD NOT set instrumentation_library_metrics. Instead - // scope_metrics SHOULD be set. - // - // Binary Protobuf receivers SHOULD check if instrumentation_library_metrics is set - // and scope_metrics is not set then the value in instrumentation_library_metrics - // SHOULD be used instead by converting InstrumentationLibraryMetrics into ScopeMetrics. - // If scope_metrics is set then instrumentation_library_metrics SHOULD be ignored. - // - // For JSON - // ======== - // JSON senders that set instrumentation_library_metrics field MAY also set - // scope_metrics to carry the same metrics, essentially double-publishing the same data. - // Such double-publishing MAY be controlled by a user-settable option. - // If double-publishing is not used then the senders SHOULD set scope_metrics and - // SHOULD NOT set instrumentation_library_metrics. - // - // JSON receivers SHOULD check if instrumentation_library_metrics is set and - // scope_metrics is not set then the value in instrumentation_library_metrics - // SHOULD be used instead by converting InstrumentationLibraryMetrics into ScopeMetrics. - // If scope_metrics is set then instrumentation_library_metrics field SHOULD be ignored. - InstrumentationLibraryMetrics []*InstrumentationLibraryMetrics `protobuf:"bytes,1000,rep,name=instrumentation_library_metrics,json=instrumentationLibraryMetrics,proto3" json:"instrumentation_library_metrics,omitempty"` // Deprecated: Do not use. // 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. SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` @@ -300,14 +272,6 @@ func (m *ResourceMetrics) GetScopeMetrics() []*ScopeMetrics { return nil } -// Deprecated: Do not use. -func (m *ResourceMetrics) GetInstrumentationLibraryMetrics() []*InstrumentationLibraryMetrics { - if m != nil { - return m.InstrumentationLibraryMetrics - } - return nil -} - func (m *ResourceMetrics) GetSchemaUrl() string { if m != nil { return m.SchemaUrl @@ -381,81 +345,10 @@ func (m *ScopeMetrics) GetSchemaUrl() string { return "" } -// A collection of Metrics produced by an InstrumentationLibrary. -// InstrumentationLibraryMetrics is wire-compatible with ScopeMetrics for binary -// Protobuf format. -// This message is deprecated and will be removed on June 15, 2022. -// -// Deprecated: Do not use. -type InstrumentationLibraryMetrics struct { - // The instrumentation library information for the metrics in this message. - // Semantically when InstrumentationLibrary isn't set, it is equivalent with - // an empty instrumentation library name (unknown). - InstrumentationLibrary v11.InstrumentationLibrary `protobuf:"bytes,1,opt,name=instrumentation_library,json=instrumentationLibrary,proto3" json:"instrumentation_library"` - // A list of metrics that originate from an instrumentation library. - Metrics []*Metric `protobuf:"bytes,2,rep,name=metrics,proto3" json:"metrics,omitempty"` - // This schema_url applies to all metrics in the "metrics" field. - SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` -} - -func (m *InstrumentationLibraryMetrics) Reset() { *m = InstrumentationLibraryMetrics{} } -func (m *InstrumentationLibraryMetrics) String() string { return proto.CompactTextString(m) } -func (*InstrumentationLibraryMetrics) ProtoMessage() {} -func (*InstrumentationLibraryMetrics) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{3} -} -func (m *InstrumentationLibraryMetrics) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *InstrumentationLibraryMetrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_InstrumentationLibraryMetrics.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *InstrumentationLibraryMetrics) XXX_Merge(src proto.Message) { - xxx_messageInfo_InstrumentationLibraryMetrics.Merge(m, src) -} -func (m *InstrumentationLibraryMetrics) XXX_Size() int { - return m.Size() -} -func (m *InstrumentationLibraryMetrics) XXX_DiscardUnknown() { - xxx_messageInfo_InstrumentationLibraryMetrics.DiscardUnknown(m) -} - -var xxx_messageInfo_InstrumentationLibraryMetrics proto.InternalMessageInfo - -func (m *InstrumentationLibraryMetrics) GetInstrumentationLibrary() v11.InstrumentationLibrary { - if m != nil { - return m.InstrumentationLibrary - } - return v11.InstrumentationLibrary{} -} - -func (m *InstrumentationLibraryMetrics) GetMetrics() []*Metric { - if m != nil { - return m.Metrics - } - return nil -} - -func (m *InstrumentationLibraryMetrics) GetSchemaUrl() string { - if m != nil { - return m.SchemaUrl - } - return "" -} - // 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/datamodel.md +// 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 @@ -564,7 +457,7 @@ func (m *Metric) Reset() { *m = Metric{} } func (m *Metric) String() string { return proto.CompactTextString(m) } func (*Metric) ProtoMessage() {} func (*Metric) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{4} + return fileDescriptor_3c3112f9fa006917, []int{3} } func (m *Metric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -712,7 +605,7 @@ func (m *Gauge) Reset() { *m = Gauge{} } func (m *Gauge) String() string { return proto.CompactTextString(m) } func (*Gauge) ProtoMessage() {} func (*Gauge) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{5} + return fileDescriptor_3c3112f9fa006917, []int{4} } func (m *Gauge) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -763,7 +656,7 @@ func (m *Sum) Reset() { *m = Sum{} } func (m *Sum) String() string { return proto.CompactTextString(m) } func (*Sum) ProtoMessage() {} func (*Sum) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{6} + return fileDescriptor_3c3112f9fa006917, []int{5} } func (m *Sum) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -826,7 +719,7 @@ func (m *Histogram) Reset() { *m = Histogram{} } func (m *Histogram) String() string { return proto.CompactTextString(m) } func (*Histogram) ProtoMessage() {} func (*Histogram) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{7} + return fileDescriptor_3c3112f9fa006917, []int{6} } func (m *Histogram) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -882,7 +775,7 @@ func (m *ExponentialHistogram) Reset() { *m = ExponentialHistogram{} } func (m *ExponentialHistogram) String() string { return proto.CompactTextString(m) } func (*ExponentialHistogram) ProtoMessage() {} func (*ExponentialHistogram) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{8} + return fileDescriptor_3c3112f9fa006917, []int{7} } func (m *ExponentialHistogram) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -939,7 +832,7 @@ func (m *Summary) Reset() { *m = Summary{} } func (m *Summary) String() string { return proto.CompactTextString(m) } func (*Summary) ProtoMessage() {} func (*Summary) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{9} + return fileDescriptor_3c3112f9fa006917, []int{8} } func (m *Summary) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1013,7 +906,7 @@ func (m *NumberDataPoint) Reset() { *m = NumberDataPoint{} } func (m *NumberDataPoint) String() string { return proto.CompactTextString(m) } func (*NumberDataPoint) ProtoMessage() {} func (*NumberDataPoint) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{10} + return fileDescriptor_3c3112f9fa006917, []int{9} } func (m *NumberDataPoint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1209,7 +1102,7 @@ func (m *HistogramDataPoint) Reset() { *m = HistogramDataPoint{} } func (m *HistogramDataPoint) String() string { return proto.CompactTextString(m) } func (*HistogramDataPoint) ProtoMessage() {} func (*HistogramDataPoint) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{11} + return fileDescriptor_3c3112f9fa006917, []int{10} } func (m *HistogramDataPoint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1461,7 +1354,7 @@ func (m *ExponentialHistogramDataPoint) Reset() { *m = ExponentialHistog func (m *ExponentialHistogramDataPoint) String() string { return proto.CompactTextString(m) } func (*ExponentialHistogramDataPoint) ProtoMessage() {} func (*ExponentialHistogramDataPoint) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{12} + return fileDescriptor_3c3112f9fa006917, []int{11} } func (m *ExponentialHistogramDataPoint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1662,7 +1555,7 @@ func (m *ExponentialHistogramDataPoint_Buckets) Reset() { *m = Exponenti func (m *ExponentialHistogramDataPoint_Buckets) String() string { return proto.CompactTextString(m) } func (*ExponentialHistogramDataPoint_Buckets) ProtoMessage() {} func (*ExponentialHistogramDataPoint_Buckets) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{12, 0} + return fileDescriptor_3c3112f9fa006917, []int{11, 0} } func (m *ExponentialHistogramDataPoint_Buckets) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1747,7 +1640,7 @@ func (m *SummaryDataPoint) Reset() { *m = SummaryDataPoint{} } func (m *SummaryDataPoint) String() string { return proto.CompactTextString(m) } func (*SummaryDataPoint) ProtoMessage() {} func (*SummaryDataPoint) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{13} + return fileDescriptor_3c3112f9fa006917, []int{12} } func (m *SummaryDataPoint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1847,7 +1740,7 @@ func (m *SummaryDataPoint_ValueAtQuantile) Reset() { *m = SummaryDataPoi func (m *SummaryDataPoint_ValueAtQuantile) String() string { return proto.CompactTextString(m) } func (*SummaryDataPoint_ValueAtQuantile) ProtoMessage() {} func (*SummaryDataPoint_ValueAtQuantile) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{13, 0} + return fileDescriptor_3c3112f9fa006917, []int{12, 0} } func (m *SummaryDataPoint_ValueAtQuantile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1926,7 +1819,7 @@ func (m *Exemplar) Reset() { *m = Exemplar{} } func (m *Exemplar) String() string { return proto.CompactTextString(m) } func (*Exemplar) ProtoMessage() {} func (*Exemplar) Descriptor() ([]byte, []int) { - return fileDescriptor_3c3112f9fa006917, []int{14} + return fileDescriptor_3c3112f9fa006917, []int{13} } func (m *Exemplar) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2020,7 +1913,6 @@ func init() { proto.RegisterType((*MetricsData)(nil), "opentelemetry.proto.metrics.v1.MetricsData") proto.RegisterType((*ResourceMetrics)(nil), "opentelemetry.proto.metrics.v1.ResourceMetrics") proto.RegisterType((*ScopeMetrics)(nil), "opentelemetry.proto.metrics.v1.ScopeMetrics") - proto.RegisterType((*InstrumentationLibraryMetrics)(nil), "opentelemetry.proto.metrics.v1.InstrumentationLibraryMetrics") proto.RegisterType((*Metric)(nil), "opentelemetry.proto.metrics.v1.Metric") proto.RegisterType((*Gauge)(nil), "opentelemetry.proto.metrics.v1.Gauge") proto.RegisterType((*Sum)(nil), "opentelemetry.proto.metrics.v1.Sum") @@ -2041,103 +1933,101 @@ func init() { } var fileDescriptor_3c3112f9fa006917 = []byte{ - // 1532 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x5b, 0x4f, 0x1b, 0x49, - 0x16, 0x76, 0xfb, 0xee, 0x63, 0x03, 0x4e, 0x2d, 0x4b, 0x5a, 0x48, 0x10, 0xc7, 0xd9, 0x0d, 0x6c, - 0x14, 0xd9, 0x1b, 0xb2, 0xf7, 0x55, 0xa4, 0xd8, 0xd8, 0x80, 0x09, 0xb7, 0x14, 0x26, 0x52, 0xa2, - 0x28, 0xad, 0xc2, 0x2e, 0x9c, 0x52, 0xba, 0xbb, 0xbc, 0xdd, 0xd5, 0x08, 0xf6, 0x27, 0xac, 0xf6, - 0x21, 0xda, 0xdf, 0xb1, 0x3f, 0x62, 0x1f, 0xf3, 0x98, 0x7d, 0x1b, 0x8d, 0x66, 0xa2, 0x19, 0xf2, - 0x30, 0x23, 0xcd, 0x3f, 0x98, 0xa7, 0x51, 0x55, 0x77, 0xe3, 0x0b, 0x06, 0xc3, 0x24, 0x23, 0x25, - 0x4f, 0x54, 0x9d, 0x3e, 0xe7, 0x3b, 0xb7, 0xaf, 0xea, 0x14, 0x86, 0xbb, 0xbc, 0x4b, 0x6d, 0x41, - 0x4d, 0x6a, 0x51, 0xe1, 0x1c, 0x97, 0xbb, 0x0e, 0x17, 0xbc, 0x2c, 0xd7, 0xac, 0xe5, 0x96, 0x0f, - 0xef, 0x85, 0xcb, 0x92, 0xfa, 0x80, 0xe6, 0x07, 0xb4, 0x7d, 0x61, 0x29, 0x54, 0x39, 0xbc, 0x37, - 0x3b, 0xdd, 0xe1, 0x1d, 0xee, 0x63, 0xc8, 0x95, 0xaf, 0x30, 0x7b, 0x67, 0x94, 0x8f, 0x16, 0xb7, - 0x2c, 0x6e, 0x4b, 0x17, 0xfe, 0x2a, 0xd0, 0x2d, 0x8d, 0xd2, 0x75, 0xa8, 0xcb, 0x3d, 0xa7, 0x45, - 0xa5, 0x76, 0xb8, 0xf6, 0xf5, 0x8b, 0x0c, 0xb2, 0x9b, 0xbe, 0xff, 0x1a, 0x11, 0x04, 0x3d, 0x83, - 0x7c, 0xa8, 0x60, 0x04, 0x71, 0xe9, 0x5a, 0x21, 0xb6, 0x98, 0x5d, 0x2a, 0x97, 0x2e, 0x8e, 0xbd, - 0x84, 0x03, 0xbb, 0x00, 0x0e, 0x4f, 0x39, 0x83, 0x82, 0xe2, 0xd7, 0x51, 0x98, 0x1a, 0x52, 0x42, - 0x8f, 0x20, 0x1d, 0xaa, 0xe9, 0x5a, 0x41, 0x5b, 0xcc, 0x2e, 0xfd, 0x6e, 0xa4, 0x9f, 0xd3, 0xa8, - 0xfb, 0x1c, 0x55, 0xe3, 0x6f, 0xde, 0xdd, 0x88, 0xe0, 0x53, 0x00, 0xf4, 0x18, 0x26, 0xdc, 0x16, - 0xef, 0xf6, 0x22, 0x8f, 0xaa, 0xc8, 0xef, 0x8e, 0x8b, 0x7c, 0x57, 0x1a, 0x85, 0x61, 0xe7, 0xdc, - 0xbe, 0x1d, 0xfa, 0x97, 0x06, 0x37, 0x98, 0xed, 0x0a, 0xc7, 0xb3, 0xa8, 0x2d, 0x88, 0x60, 0xdc, - 0x36, 0x4c, 0xb6, 0xef, 0x10, 0xe7, 0xf8, 0xd4, 0xcb, 0xf7, 0x29, 0xe5, 0xe6, 0xc1, 0x38, 0x37, - 0x8d, 0x41, 0x9c, 0x0d, 0x1f, 0x26, 0xf0, 0x54, 0x8d, 0xea, 0x1a, 0x9e, 0x63, 0x17, 0xa9, 0xa0, - 0x39, 0x00, 0xb7, 0xf5, 0x92, 0x5a, 0xc4, 0xf0, 0x1c, 0x53, 0x8f, 0x15, 0xb4, 0xc5, 0x0c, 0xce, - 0xf8, 0x92, 0x3d, 0xc7, 0x2c, 0xfe, 0x4f, 0x83, 0x5c, 0x7f, 0x2a, 0x68, 0x1b, 0x12, 0x2a, 0x99, - 0xa0, 0xb2, 0xf7, 0x47, 0x06, 0x18, 0xb0, 0xe7, 0x6c, 0x7c, 0x0a, 0x2a, 0xa8, 0xb1, 0x8f, 0x83, - 0x1e, 0x42, 0x6a, 0xb0, 0xb4, 0xb7, 0xc7, 0xe5, 0xec, 0x87, 0x82, 0x43, 0xb3, 0x71, 0x29, 0xfc, - 0xa8, 0xc1, 0xdc, 0x85, 0x65, 0x42, 0x02, 0xae, 0x9f, 0xd3, 0x8f, 0x20, 0xcb, 0x3f, 0x5e, 0x2d, - 0xcb, 0x00, 0x3e, 0xc8, 0x73, 0x66, 0x74, 0x03, 0x7e, 0xf1, 0xc4, 0xff, 0x16, 0xd5, 0xb5, 0xe2, - 0xb7, 0x31, 0x48, 0xfa, 0x66, 0x08, 0x41, 0xdc, 0x26, 0x96, 0xdf, 0xb8, 0x0c, 0x56, 0x6b, 0x54, - 0x80, 0x6c, 0x9b, 0xba, 0x2d, 0x87, 0x75, 0x65, 0x64, 0x7a, 0x54, 0x7d, 0xea, 0x17, 0x49, 0x2b, - 0xcf, 0x66, 0x22, 0x40, 0x57, 0x6b, 0xf4, 0x00, 0x12, 0x1d, 0xe2, 0x75, 0xa8, 0x9e, 0x50, 0xd5, - 0xf9, 0xed, 0xb8, 0xb8, 0x57, 0xa5, 0xf2, 0x5a, 0x04, 0xfb, 0x56, 0xe8, 0xcf, 0x10, 0x73, 0x3d, - 0x4b, 0x4f, 0x29, 0xe3, 0x5b, 0x63, 0x0f, 0x92, 0x67, 0xad, 0x45, 0xb0, 0xb4, 0x40, 0x0d, 0xc8, - 0xbc, 0x64, 0xae, 0xe0, 0x1d, 0x87, 0x58, 0x7a, 0xe6, 0x82, 0x93, 0xdd, 0x67, 0xbe, 0x16, 0x1a, - 0xac, 0x45, 0x70, 0xcf, 0x1a, 0xbd, 0x82, 0x5f, 0xd3, 0xa3, 0x2e, 0xb7, 0xa9, 0x2d, 0x18, 0x31, - 0x8d, 0x1e, 0x2c, 0x28, 0xd8, 0x3f, 0x8c, 0x83, 0xad, 0xf7, 0x8c, 0xfb, 0x3d, 0x4c, 0xd3, 0x11, - 0x72, 0xb4, 0x0c, 0x29, 0xd7, 0xb3, 0x2c, 0xc9, 0xa7, 0xac, 0x82, 0x5f, 0xb8, 0x44, 0xd2, 0x52, - 0x7d, 0x2d, 0x82, 0x43, 0xcb, 0x6a, 0x12, 0xe2, 0x6d, 0x22, 0xc8, 0x7a, 0x3c, 0x1d, 0xcf, 0x27, - 0xd6, 0xe3, 0xe9, 0x64, 0x3e, 0xb5, 0x1e, 0x4f, 0xa7, 0xf3, 0x99, 0xe2, 0x53, 0x48, 0xa8, 0x0a, - 0xa3, 0x1d, 0xc8, 0x4a, 0x15, 0xa3, 0xcb, 0x99, 0x2d, 0x2e, 0x7d, 0xc7, 0x6e, 0x79, 0xd6, 0x3e, - 0x75, 0xe4, 0x4d, 0xbd, 0x23, 0xed, 0x30, 0xb4, 0xc3, 0xa5, 0x5b, 0xfc, 0x41, 0x83, 0xd8, 0xae, - 0x67, 0x7d, 0x7c, 0x64, 0xc4, 0xe1, 0x3a, 0xe9, 0x74, 0x1c, 0xda, 0xf1, 0xcf, 0x9b, 0xa0, 0x56, - 0x97, 0x3b, 0xc4, 0x64, 0xe2, 0x58, 0xb1, 0x70, 0x72, 0xe9, 0x4f, 0xe3, 0xd0, 0x2b, 0x3d, 0xf3, - 0x66, 0xcf, 0x1a, 0xcf, 0x90, 0x91, 0x72, 0x74, 0x13, 0x72, 0xcc, 0x35, 0x2c, 0x6e, 0x73, 0xc1, - 0x6d, 0xd6, 0x52, 0x84, 0x4e, 0xe3, 0x2c, 0x73, 0x37, 0x43, 0x51, 0xf1, 0xff, 0x1a, 0x64, 0x7a, - 0x5d, 0xdb, 0x1d, 0x95, 0xf3, 0xd2, 0xa5, 0xf9, 0xf6, 0x69, 0xa4, 0x5d, 0xfc, 0x4e, 0x83, 0xe9, - 0x51, 0x64, 0x45, 0x2f, 0x46, 0xa5, 0xf7, 0xe0, 0xe7, 0xf0, 0xfe, 0x13, 0xc9, 0xf4, 0x39, 0xa4, - 0x82, 0x63, 0x83, 0x1e, 0x8f, 0xca, 0xed, 0xf7, 0x97, 0x3c, 0x74, 0xa3, 0x4f, 0xc2, 0x49, 0x14, - 0xa6, 0x86, 0xf8, 0x8c, 0x36, 0x01, 0x88, 0x10, 0x0e, 0xdb, 0xf7, 0x04, 0x75, 0x75, 0x7f, 0x62, - 0x2f, 0x8c, 0x19, 0x15, 0x8f, 0xe8, 0xf1, 0x13, 0x62, 0x7a, 0xe1, 0x10, 0xec, 0x03, 0x40, 0x65, - 0x98, 0x76, 0x05, 0x71, 0x84, 0x21, 0x98, 0x45, 0x0d, 0xcf, 0x66, 0x47, 0x86, 0x4d, 0x6c, 0xae, - 0xca, 0x95, 0xc4, 0xd7, 0xd4, 0xb7, 0x26, 0xb3, 0xe8, 0x9e, 0xcd, 0x8e, 0xb6, 0x88, 0xcd, 0xd1, - 0x6f, 0x60, 0x72, 0x48, 0x35, 0xa6, 0x54, 0x73, 0xa2, 0x5f, 0x6b, 0x0e, 0x32, 0xc4, 0x35, 0xda, - 0xdc, 0xdb, 0x37, 0xa9, 0x1e, 0x2f, 0x68, 0x8b, 0xda, 0x5a, 0x04, 0xa7, 0x89, 0x5b, 0x53, 0x12, - 0x74, 0x1d, 0x92, 0xc4, 0x35, 0x98, 0x2d, 0xf4, 0x64, 0x41, 0x5b, 0xcc, 0xcb, 0x6b, 0x9a, 0xb8, - 0x0d, 0x5b, 0xa0, 0x0d, 0xc8, 0xd0, 0x23, 0x6a, 0x75, 0x4d, 0xe2, 0xb8, 0x7a, 0x42, 0x25, 0xb7, - 0x38, 0x9e, 0x1e, 0xbe, 0x41, 0x90, 0x5d, 0x0f, 0x00, 0x4d, 0x43, 0xe2, 0xc0, 0x24, 0x1d, 0x57, - 0x4f, 0x17, 0xb4, 0xc5, 0x09, 0xec, 0x6f, 0xaa, 0x29, 0x48, 0x1c, 0xca, 0x6a, 0xac, 0xc7, 0xd3, - 0x5a, 0x3e, 0x5a, 0xfc, 0x2a, 0x06, 0xe8, 0x2c, 0xad, 0x86, 0xea, 0x9c, 0xf9, 0x44, 0xeb, 0x3c, - 0x0d, 0x89, 0x16, 0xf7, 0x6c, 0xa1, 0x6a, 0x9c, 0xc4, 0xfe, 0x06, 0x21, 0x7f, 0xd8, 0x25, 0x82, - 0xba, 0xab, 0x39, 0x76, 0x0b, 0x26, 0xf6, 0xbd, 0xd6, 0x2b, 0x2a, 0x0c, 0xa5, 0xe3, 0xea, 0xc9, - 0x42, 0x4c, 0xc2, 0xf9, 0xc2, 0x65, 0x25, 0x43, 0x0b, 0x30, 0x45, 0x8f, 0xba, 0x26, 0x6b, 0x31, - 0x61, 0xec, 0x73, 0xcf, 0x6e, 0xfb, 0x0c, 0xd3, 0xf0, 0x64, 0x28, 0xae, 0x2a, 0xe9, 0x60, 0x9f, - 0xd2, 0x1f, 0xad, 0x4f, 0xd0, 0xd7, 0x27, 0x99, 0x85, 0xc5, 0x6c, 0x35, 0xbd, 0xb4, 0x35, 0x0d, - 0xcb, 0x8d, 0x92, 0x91, 0x23, 0x3d, 0xa7, 0x64, 0x51, 0x2c, 0x37, 0x72, 0x48, 0xb9, 0x9e, 0x65, - 0xc8, 0xbf, 0x16, 0xb3, 0xfd, 0xbf, 0xe4, 0xc8, 0x08, 0xda, 0x7b, 0x92, 0x80, 0xb9, 0x0b, 0x2f, - 0x90, 0xa1, 0x4e, 0x6b, 0x9f, 0x7d, 0xa7, 0xa7, 0xe5, 0x6b, 0x99, 0x98, 0x54, 0x9d, 0xad, 0x6b, - 0xd8, 0xdf, 0xc8, 0x77, 0xdb, 0x3f, 0xa9, 0xc3, 0xfd, 0xee, 0xab, 0x77, 0x50, 0x12, 0x67, 0xa4, - 0x44, 0xb5, 0x1e, 0x75, 0x20, 0xdd, 0xe5, 0x2e, 0x13, 0xec, 0x90, 0xaa, 0xd3, 0x92, 0x5d, 0xaa, - 0x7f, 0xd0, 0xb5, 0x5c, 0xaa, 0x2a, 0x5e, 0xb9, 0xe1, 0xff, 0x36, 0x21, 0xb8, 0x74, 0x64, 0xab, - 0x8b, 0xf4, 0x90, 0x06, 0xcf, 0xa9, 0x8f, 0xeb, 0x28, 0x04, 0x3f, 0x87, 0x54, 0x03, 0xc4, 0xcd, - 0x7e, 0x28, 0x71, 0x03, 0x8a, 0xe6, 0x46, 0x50, 0x74, 0xa2, 0x8f, 0xa2, 0xb3, 0x2b, 0x90, 0x0a, - 0xc2, 0x44, 0x33, 0x90, 0xe4, 0x07, 0x07, 0x2e, 0x15, 0xea, 0x4d, 0x7c, 0x0d, 0x07, 0xbb, 0xb3, - 0xe7, 0x53, 0xbe, 0xcf, 0xe3, 0x83, 0xe7, 0xf3, 0x3c, 0xaa, 0x17, 0xff, 0x1b, 0x83, 0xfc, 0xf0, - 0x24, 0xf9, 0x4c, 0x26, 0xc5, 0x68, 0x5e, 0xe7, 0xfb, 0x78, 0xed, 0xb3, 0x9a, 0xc1, 0xd4, 0x3f, - 0x3c, 0x62, 0x0b, 0x66, 0x52, 0x43, 0x5d, 0xdf, 0xfe, 0x0d, 0x96, 0x5d, 0x7a, 0x78, 0xd5, 0x11, - 0x5b, 0x52, 0x19, 0x56, 0xc4, 0xe3, 0x00, 0x0e, 0x4f, 0x86, 0xc0, 0xea, 0xc3, 0x39, 0x63, 0x63, - 0x76, 0x19, 0xa6, 0x86, 0x0c, 0xd1, 0x2c, 0xa4, 0x43, 0x53, 0xd5, 0x4d, 0x0d, 0x9f, 0xee, 0x25, - 0x88, 0x0a, 0x53, 0xd5, 0x47, 0xc3, 0x03, 0x23, 0xe7, 0x75, 0x0c, 0xd2, 0x21, 0xa9, 0xd0, 0x0b, - 0xf8, 0xd5, 0x01, 0x33, 0x05, 0x75, 0x68, 0xdb, 0xf8, 0xd0, 0x7e, 0xa1, 0x10, 0xa9, 0xd2, 0xeb, - 0xdb, 0xd9, 0x36, 0x44, 0xc7, 0x0d, 0xec, 0xd8, 0xe5, 0x07, 0xf6, 0x53, 0x48, 0xb9, 0x5d, 0x62, - 0x1b, 0xac, 0xad, 0x1a, 0x98, 0xab, 0x3e, 0x94, 0x81, 0x7c, 0xf9, 0xee, 0xc6, 0x5f, 0x3a, 0x7c, - 0x28, 0x76, 0xc6, 0xcb, 0x2d, 0x6e, 0x9a, 0xb4, 0x25, 0xb8, 0x53, 0xee, 0xca, 0x67, 0x4e, 0x99, - 0xd9, 0x82, 0x3a, 0x36, 0x31, 0xcb, 0x72, 0x57, 0xda, 0xed, 0x12, 0xbb, 0x51, 0xc3, 0x49, 0x09, - 0xd8, 0x68, 0xa3, 0xe7, 0x90, 0x16, 0x0e, 0x69, 0x51, 0x89, 0x9d, 0x50, 0xd8, 0x95, 0x00, 0xfb, - 0xaf, 0x57, 0xc7, 0x6e, 0x4a, 0xa4, 0x46, 0x0d, 0xa7, 0x14, 0x64, 0xa3, 0x3d, 0xf4, 0x0a, 0xb8, - 0xf3, 0x6f, 0x0d, 0x66, 0x46, 0xbf, 0xfd, 0xd0, 0x02, 0xdc, 0xaa, 0xac, 0xae, 0xe2, 0xfa, 0x6a, - 0xa5, 0xd9, 0xd8, 0xde, 0x32, 0x9a, 0xf5, 0xcd, 0x9d, 0x6d, 0x5c, 0xd9, 0x68, 0x34, 0x9f, 0x1a, - 0x7b, 0x5b, 0xbb, 0x3b, 0xf5, 0xe5, 0xc6, 0x4a, 0xa3, 0x5e, 0xcb, 0x47, 0xd0, 0x4d, 0x98, 0x3b, - 0x4f, 0xb1, 0x56, 0xdf, 0x68, 0x56, 0xf2, 0x1a, 0xba, 0x0d, 0xc5, 0xf3, 0x54, 0x96, 0xf7, 0x36, - 0xf7, 0x36, 0x2a, 0xcd, 0xc6, 0x93, 0x7a, 0x3e, 0x7a, 0xe7, 0xef, 0x30, 0x79, 0xca, 0xd7, 0x15, - 0x75, 0x71, 0x4d, 0x40, 0x66, 0x65, 0xa3, 0xb2, 0x6a, 0x6c, 0x6d, 0x6f, 0xd5, 0xf3, 0x11, 0x34, - 0x0b, 0x33, 0xc1, 0xd6, 0xc0, 0xf5, 0xe5, 0x6d, 0x5c, 0xab, 0xd7, 0x8c, 0x27, 0x95, 0x8d, 0xbd, - 0x7a, 0x5e, 0xab, 0xfe, 0x47, 0x7b, 0x73, 0x32, 0xaf, 0xbd, 0x3d, 0x99, 0xd7, 0xbe, 0x39, 0x99, - 0xd7, 0x5e, 0xbf, 0x9f, 0x8f, 0xbc, 0x7d, 0x3f, 0x1f, 0xf9, 0xe2, 0xfd, 0x7c, 0x04, 0x6e, 0x32, - 0x3e, 0xe6, 0xb8, 0x54, 0x73, 0xc1, 0x2f, 0x14, 0x3b, 0xf2, 0xc3, 0x8e, 0xf6, 0xac, 0x7e, 0xe5, - 0x62, 0xfb, 0x3f, 0xd6, 0x75, 0xa8, 0xdd, 0xf7, 0xfb, 0xe1, 0x7e, 0x52, 0x09, 0xef, 0xff, 0x14, - 0x00, 0x00, 0xff, 0xff, 0xab, 0x2c, 0xf9, 0xc6, 0x68, 0x14, 0x00, 0x00, + // 1490 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0xcd, 0x6e, 0x1b, 0xbf, + 0x11, 0xd7, 0xea, 0x5b, 0x23, 0xd9, 0x56, 0x58, 0xd7, 0x11, 0x0c, 0x58, 0x51, 0x94, 0x36, 0x76, + 0x83, 0x40, 0xaa, 0x9d, 0xa2, 0x1f, 0x28, 0x02, 0x44, 0xb2, 0x64, 0x5b, 0x8e, 0xbf, 0x42, 0xcb, + 0x06, 0x12, 0x04, 0x59, 0xd0, 0x12, 0xad, 0x10, 0xd9, 0x25, 0xd5, 0x5d, 0xae, 0x61, 0xf7, 0x19, + 0x7a, 0xc8, 0x73, 0x14, 0xbd, 0xf5, 0x05, 0x7a, 0xcc, 0x31, 0xbd, 0x05, 0x45, 0x11, 0xb4, 0xce, + 0xa1, 0x2d, 0xfa, 0x12, 0x7f, 0x90, 0xbb, 0x6b, 0xc9, 0x8a, 0x1c, 0x39, 0xff, 0xe4, 0x90, 0x9c, + 0x96, 0x1c, 0xce, 0xfc, 0x38, 0xc3, 0xf9, 0x91, 0x33, 0x58, 0xb8, 0x2f, 0xfa, 0x94, 0x4b, 0x6a, + 0x51, 0x9b, 0x4a, 0xe7, 0xac, 0xda, 0x77, 0x84, 0x14, 0x55, 0x35, 0x66, 0x1d, 0xb7, 0x7a, 0xb2, + 0x1c, 0x0e, 0x2b, 0x7a, 0x01, 0x15, 0x2f, 0x69, 0xfb, 0xc2, 0x4a, 0xa8, 0x72, 0xb2, 0x3c, 0x3f, + 0xdb, 0x13, 0x3d, 0xe1, 0x63, 0xa8, 0x91, 0xaf, 0x30, 0x7f, 0x6f, 0xdc, 0x1e, 0x1d, 0x61, 0xdb, + 0x82, 0xab, 0x2d, 0xfc, 0x51, 0xa0, 0x5b, 0x19, 0xa7, 0xeb, 0x50, 0x57, 0x78, 0x4e, 0x87, 0x2a, + 0xed, 0x70, 0xec, 0xeb, 0x97, 0x19, 0x64, 0xb7, 0xfd, 0xfd, 0x1b, 0x44, 0x12, 0xf4, 0x0c, 0xf2, + 0xa1, 0x82, 0x19, 0xf8, 0x55, 0x30, 0x4a, 0xb1, 0xa5, 0xec, 0x4a, 0xb5, 0xf2, 0x69, 0xdf, 0x2b, + 0x38, 0xb0, 0x0b, 0xe0, 0xf0, 0x8c, 0x73, 0x59, 0x50, 0x7e, 0x67, 0xc0, 0xcc, 0x88, 0x12, 0x7a, + 0x0c, 0xe9, 0x50, 0xad, 0x60, 0x94, 0x8c, 0xa5, 0xec, 0xca, 0x2f, 0xc6, 0xee, 0x73, 0xe1, 0xf5, + 0xd0, 0x46, 0xf5, 0xf8, 0x9b, 0xf7, 0xb7, 0x22, 0xf8, 0x02, 0x00, 0x3d, 0x81, 0x29, 0xb7, 0x23, + 0xfa, 0x03, 0xcf, 0xa3, 0xda, 0xf3, 0xfb, 0x93, 0x3c, 0xdf, 0x57, 0x46, 0xa1, 0xdb, 0x39, 0x77, + 0x68, 0x86, 0x16, 0x00, 0xdc, 0xce, 0x4b, 0x6a, 0x13, 0xd3, 0x73, 0xac, 0x42, 0xac, 0x64, 0x2c, + 0x65, 0x70, 0xc6, 0x97, 0x1c, 0x38, 0xd6, 0x66, 0x32, 0xfd, 0xdf, 0x54, 0xfe, 0x7f, 0xa9, 0xf2, + 0xdf, 0x0c, 0xc8, 0x0d, 0xa3, 0xa0, 0x5d, 0x48, 0x68, 0x9c, 0x20, 0xa8, 0x07, 0x63, 0x5d, 0x08, + 0x12, 0x77, 0xb2, 0x5c, 0x69, 0x71, 0x57, 0x3a, 0x9e, 0x4d, 0xb9, 0x24, 0x92, 0x09, 0xae, 0xa1, + 0x82, 0xf0, 0x7c, 0x1c, 0xf4, 0x08, 0x52, 0x97, 0xa3, 0xba, 0x3b, 0x29, 0x2a, 0xdf, 0x15, 0x1c, + 0x9a, 0x4d, 0x08, 0xa5, 0xfc, 0xef, 0x18, 0x24, 0x7d, 0x13, 0x84, 0x20, 0xce, 0x89, 0xed, 0xfb, + 0x9e, 0xc1, 0x7a, 0x8c, 0x4a, 0x90, 0xed, 0x52, 0xb7, 0xe3, 0xb0, 0xbe, 0x72, 0xb0, 0x10, 0xd5, + 0x4b, 0xc3, 0x22, 0x65, 0xe5, 0x71, 0x26, 0x03, 0x64, 0x3d, 0x46, 0x0f, 0x21, 0xd1, 0x23, 0x5e, + 0x8f, 0x16, 0x12, 0xfa, 0x18, 0x7e, 0x3e, 0xc9, 0xe7, 0x75, 0xa5, 0xbc, 0x11, 0xc1, 0xbe, 0x15, + 0xfa, 0x0d, 0xc4, 0x5c, 0xcf, 0x2e, 0xa4, 0xb4, 0xf1, 0x9d, 0x89, 0x69, 0xf4, 0xec, 0x8d, 0x08, + 0x56, 0x16, 0xa8, 0x05, 0x99, 0x97, 0xcc, 0x95, 0xa2, 0xe7, 0x10, 0xbb, 0x90, 0xf9, 0x04, 0xaf, + 0x86, 0xcc, 0x37, 0x42, 0x83, 0x8d, 0x08, 0x1e, 0x58, 0xa3, 0x57, 0xf0, 0x53, 0x7a, 0xda, 0x17, + 0x9c, 0x72, 0xc9, 0x88, 0x65, 0x0e, 0x60, 0x41, 0xc3, 0xfe, 0x6a, 0x12, 0x6c, 0x73, 0x60, 0x3c, + 0xbc, 0xc3, 0x2c, 0x1d, 0x23, 0x47, 0xab, 0x90, 0x72, 0x3d, 0xdb, 0x26, 0xce, 0x59, 0x21, 0xab, + 0xe1, 0x17, 0xaf, 0x11, 0xb4, 0x52, 0xdf, 0x88, 0xe0, 0xd0, 0xb2, 0x9e, 0x84, 0x78, 0x97, 0x48, + 0xb2, 0x19, 0x4f, 0xc7, 0xf3, 0x89, 0xcd, 0x78, 0x3a, 0x99, 0x4f, 0x6d, 0xc6, 0xd3, 0xe9, 0x7c, + 0xa6, 0xfc, 0x14, 0x12, 0xfa, 0x84, 0xd1, 0x1e, 0x64, 0x95, 0x8a, 0xd9, 0x17, 0x8c, 0xcb, 0x6b, + 0xdf, 0xf0, 0x1d, 0xcf, 0x3e, 0xa2, 0x8e, 0x7a, 0x27, 0xf6, 0x94, 0x1d, 0x86, 0x6e, 0x38, 0x74, + 0xcb, 0xff, 0x37, 0x20, 0xb6, 0xef, 0xd9, 0x5f, 0x1f, 0x19, 0x09, 0xb8, 0x49, 0x7a, 0x3d, 0x87, + 0xf6, 0xf4, 0xd5, 0x30, 0x25, 0xb5, 0xfb, 0xc2, 0x21, 0x16, 0x93, 0x67, 0x9a, 0x85, 0xd3, 0x2b, + 0xbf, 0x9e, 0x84, 0x5e, 0x1b, 0x98, 0xb7, 0x07, 0xd6, 0x78, 0x8e, 0x8c, 0x95, 0xa3, 0xdb, 0x90, + 0x63, 0xae, 0x69, 0x0b, 0x2e, 0xa4, 0xe0, 0xac, 0xa3, 0x09, 0x9d, 0xc6, 0x59, 0xe6, 0x6e, 0x87, + 0xa2, 0xf2, 0xdf, 0x0d, 0xc8, 0x0c, 0xb2, 0xb6, 0x3f, 0x2e, 0xe6, 0x95, 0x6b, 0xf3, 0xed, 0xdb, + 0x08, 0xbb, 0xfc, 0x1f, 0x03, 0x66, 0xc7, 0x91, 0x15, 0xbd, 0x18, 0x17, 0xde, 0xc3, 0x1f, 0xc3, + 0xfb, 0x6f, 0x24, 0xd2, 0xe7, 0x90, 0x0a, 0xae, 0x0d, 0x7a, 0x32, 0x2e, 0xb6, 0x5f, 0x5e, 0xf3, + 0xd2, 0x8d, 0xbf, 0x09, 0xe7, 0x51, 0x98, 0x19, 0xe1, 0x33, 0xda, 0x06, 0x20, 0x52, 0x3a, 0xec, + 0xc8, 0x93, 0xd4, 0x2d, 0xa4, 0xf4, 0x2e, 0x8b, 0x13, 0x6a, 0xc2, 0x63, 0x7a, 0x76, 0x48, 0x2c, + 0x2f, 0xac, 0x03, 0x43, 0x00, 0xa8, 0x0a, 0xb3, 0xae, 0x24, 0x8e, 0x34, 0x25, 0xb3, 0xa9, 0xe9, + 0x71, 0x76, 0x6a, 0x72, 0xc2, 0x85, 0x3e, 0xae, 0x24, 0xbe, 0xa1, 0xd7, 0xda, 0xcc, 0xa6, 0x07, + 0x9c, 0x9d, 0xee, 0x10, 0x2e, 0xd0, 0xcf, 0x60, 0x7a, 0x44, 0x35, 0xa6, 0x55, 0x73, 0x72, 0x58, + 0x6b, 0x01, 0x32, 0xc4, 0x35, 0xbb, 0xc2, 0x3b, 0xb2, 0x68, 0x21, 0x5e, 0x32, 0x96, 0x8c, 0x8d, + 0x08, 0x4e, 0x13, 0xb7, 0xa1, 0x25, 0xe8, 0x26, 0x24, 0x89, 0x6b, 0x32, 0x2e, 0x0b, 0xc9, 0x92, + 0xb1, 0x94, 0x57, 0xcf, 0x34, 0x71, 0x5b, 0x5c, 0xa2, 0x2d, 0xc8, 0xd0, 0x53, 0x6a, 0xf7, 0x2d, + 0xe2, 0xb8, 0x85, 0x84, 0x0e, 0x6e, 0x69, 0x32, 0x3d, 0x7c, 0x83, 0x20, 0xba, 0x01, 0x00, 0x9a, + 0x85, 0xc4, 0xb1, 0x45, 0x7a, 0x6e, 0x21, 0x5d, 0x32, 0x96, 0xa6, 0xb0, 0x3f, 0xa9, 0xa7, 0x20, + 0x71, 0xa2, 0x4e, 0x63, 0x33, 0x9e, 0x36, 0xf2, 0xd1, 0xf2, 0x3f, 0x63, 0x80, 0x3e, 0xa6, 0xd5, + 0xc8, 0x39, 0x67, 0xbe, 0xd1, 0x73, 0x9e, 0x85, 0x44, 0x47, 0x78, 0x5c, 0xea, 0x33, 0x4e, 0x62, + 0x7f, 0x82, 0x90, 0x5f, 0xec, 0x12, 0xc1, 0xb9, 0xeb, 0x3a, 0x76, 0x07, 0xa6, 0x8e, 0xbc, 0xce, + 0x2b, 0x2a, 0x4d, 0xad, 0xe3, 0x16, 0x92, 0xa5, 0x98, 0x82, 0xf3, 0x85, 0xab, 0x5a, 0x86, 0x16, + 0x61, 0x86, 0x9e, 0xf6, 0x2d, 0xd6, 0x61, 0xd2, 0x3c, 0x12, 0x1e, 0xef, 0xfa, 0x0c, 0x33, 0xf0, + 0x74, 0x28, 0xae, 0x6b, 0xe9, 0xe5, 0x3c, 0xa5, 0xbf, 0x5a, 0x9e, 0x60, 0x28, 0x4f, 0x2a, 0x0a, + 0x9b, 0x71, 0x5d, 0xbd, 0x8c, 0x0d, 0x03, 0xab, 0x89, 0x96, 0x91, 0xd3, 0x42, 0x4e, 0xcb, 0xa2, + 0x58, 0x4d, 0x54, 0x91, 0x72, 0x3d, 0xdb, 0x54, 0x5f, 0x9b, 0x71, 0xff, 0x4b, 0x4e, 0xcd, 0x20, + 0xbd, 0xe7, 0x09, 0x58, 0xf8, 0xe4, 0x03, 0x32, 0x92, 0x69, 0xe3, 0xbb, 0xcf, 0xf4, 0xac, 0x6a, + 0x18, 0x89, 0x45, 0xf5, 0xdd, 0xba, 0x81, 0xfd, 0x89, 0xea, 0xd9, 0xfe, 0x48, 0x1d, 0xe1, 0x67, + 0x5f, 0xf7, 0x41, 0x49, 0x9c, 0x51, 0x12, 0x9d, 0x7a, 0xd4, 0x83, 0x74, 0x5f, 0xb8, 0x4c, 0xb2, + 0x13, 0xaa, 0x6f, 0x4b, 0x76, 0xa5, 0xf9, 0x45, 0xcf, 0x72, 0xa5, 0xae, 0x79, 0xe5, 0x86, 0x9d, + 0x75, 0x08, 0xae, 0x36, 0xe2, 0xfa, 0x21, 0x3d, 0xa1, 0x41, 0x3b, 0xf5, 0x75, 0x37, 0x0a, 0xc1, + 0xaf, 0x20, 0xd5, 0x25, 0xe2, 0x66, 0xbf, 0x94, 0xb8, 0x01, 0x45, 0x73, 0x63, 0x28, 0x3a, 0x35, + 0x44, 0xd1, 0xf9, 0x35, 0x48, 0x05, 0x6e, 0xa2, 0x39, 0x48, 0x8a, 0xe3, 0x63, 0x97, 0x4a, 0xdd, + 0x13, 0xdf, 0xc0, 0xc1, 0xec, 0xe3, 0xfb, 0xa9, 0x7a, 0xf3, 0xf8, 0xe5, 0xfb, 0x79, 0x15, 0xd5, + 0xcb, 0x7f, 0x89, 0x41, 0x7e, 0xb4, 0x92, 0x7c, 0x27, 0x95, 0x62, 0x3c, 0xaf, 0xf3, 0x43, 0xbc, + 0xf6, 0x59, 0xcd, 0x60, 0xe6, 0x0f, 0x1e, 0xe1, 0x92, 0x59, 0xd4, 0xd4, 0xcf, 0xb7, 0xff, 0x82, + 0x65, 0x57, 0x1e, 0x7d, 0x6e, 0x89, 0xad, 0xe8, 0x08, 0x6b, 0xf2, 0x49, 0x00, 0x87, 0xa7, 0x43, + 0x60, 0xbd, 0x70, 0x45, 0xd9, 0x98, 0x5f, 0x85, 0x99, 0x11, 0x43, 0x34, 0x0f, 0xe9, 0xd0, 0x54, + 0x67, 0xd3, 0xc0, 0x17, 0x73, 0x05, 0xa2, 0xdd, 0xd4, 0xe7, 0x63, 0xe0, 0x4b, 0x25, 0xe7, 0x75, + 0x0c, 0xd2, 0x21, 0xa9, 0xd0, 0x0b, 0xf8, 0xc9, 0x31, 0xb3, 0x24, 0x75, 0x68, 0xd7, 0xfc, 0xd2, + 0x7c, 0xa1, 0x10, 0xa9, 0x36, 0xc8, 0xdb, 0xc7, 0x69, 0x88, 0x4e, 0x2a, 0xd8, 0xb1, 0xeb, 0x17, + 0xec, 0xa7, 0x90, 0x72, 0xfb, 0x84, 0x9b, 0xac, 0xab, 0x13, 0x98, 0xab, 0x3f, 0x52, 0x8e, 0xfc, + 0xe3, 0xfd, 0xad, 0xdf, 0xf6, 0xc4, 0x88, 0xef, 0x4c, 0x54, 0x3b, 0xc2, 0xb2, 0x68, 0x47, 0x0a, + 0xa7, 0xda, 0x57, 0x6d, 0x4e, 0x95, 0x71, 0x49, 0x1d, 0x4e, 0xac, 0xaa, 0x9a, 0x55, 0xf6, 0xfb, + 0x84, 0xb7, 0x1a, 0x38, 0xa9, 0x00, 0x5b, 0x5d, 0xf4, 0x1c, 0xd2, 0xd2, 0x21, 0x1d, 0xaa, 0xb0, + 0x13, 0x1a, 0xbb, 0x16, 0x60, 0xff, 0xee, 0xf3, 0xb1, 0xdb, 0x0a, 0xa9, 0xd5, 0xc0, 0x29, 0x0d, + 0xd9, 0xea, 0x8e, 0x74, 0x01, 0xf7, 0xfe, 0x64, 0xc0, 0xdc, 0xf8, 0xde, 0x0f, 0x2d, 0xc2, 0x9d, + 0xda, 0xfa, 0x3a, 0x6e, 0xae, 0xd7, 0xda, 0xad, 0xdd, 0x1d, 0xb3, 0xdd, 0xdc, 0xde, 0xdb, 0xc5, + 0xb5, 0xad, 0x56, 0xfb, 0xa9, 0x79, 0xb0, 0xb3, 0xbf, 0xd7, 0x5c, 0x6d, 0xad, 0xb5, 0x9a, 0x8d, + 0x7c, 0x04, 0xdd, 0x86, 0x85, 0xab, 0x14, 0x1b, 0xcd, 0xad, 0x76, 0x2d, 0x6f, 0xa0, 0xbb, 0x50, + 0xbe, 0x4a, 0x65, 0xf5, 0x60, 0xfb, 0x60, 0xab, 0xd6, 0x6e, 0x1d, 0x36, 0xf3, 0xd1, 0x7b, 0xbf, + 0x87, 0xe9, 0x0b, 0xbe, 0xae, 0xe9, 0x87, 0x6b, 0x0a, 0x32, 0x6b, 0x5b, 0xb5, 0x75, 0x73, 0x67, + 0x77, 0xa7, 0x99, 0x8f, 0xa0, 0x79, 0x98, 0x0b, 0xa6, 0x26, 0x6e, 0xae, 0xee, 0xe2, 0x46, 0xb3, + 0x61, 0x1e, 0xd6, 0xb6, 0x0e, 0x9a, 0x79, 0xa3, 0xfe, 0x57, 0xe3, 0xcd, 0x79, 0xd1, 0x78, 0x7b, + 0x5e, 0x34, 0xfe, 0x75, 0x5e, 0x34, 0x5e, 0x7f, 0x28, 0x46, 0xde, 0x7e, 0x28, 0x46, 0xde, 0x7d, + 0x28, 0x46, 0xe0, 0x36, 0x13, 0x13, 0xae, 0x4b, 0x3d, 0x17, 0xfc, 0x78, 0xd8, 0x53, 0x0b, 0x7b, + 0xc6, 0xb3, 0xe6, 0x67, 0x1f, 0xb6, 0xff, 0xab, 0xa8, 0x47, 0xf9, 0xd0, 0xdf, 0xab, 0x3f, 0x47, + 0x8b, 0xbb, 0x7d, 0xca, 0xdb, 0x17, 0x20, 0x1a, 0x3e, 0xf8, 0xb3, 0xe0, 0x56, 0x0e, 0x97, 0x8f, + 0x92, 0xda, 0xea, 0xc1, 0x0f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x26, 0xf7, 0xb5, 0x07, 0x13, + 0x00, 0x00, } func (m *MetricsData) Marshal() (dAtA []byte, err error) { @@ -2197,22 +2087,6 @@ func (m *ResourceMetrics) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if len(m.InstrumentationLibraryMetrics) > 0 { - for iNdEx := len(m.InstrumentationLibraryMetrics) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.InstrumentationLibraryMetrics[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintMetrics(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3e - i-- - dAtA[i] = 0xc2 - } - } if len(m.SchemaUrl) > 0 { i -= len(m.SchemaUrl) copy(dAtA[i:], m.SchemaUrl) @@ -2301,60 +2175,6 @@ func (m *ScopeMetrics) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *InstrumentationLibraryMetrics) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *InstrumentationLibraryMetrics) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *InstrumentationLibraryMetrics) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.SchemaUrl) > 0 { - i -= len(m.SchemaUrl) - copy(dAtA[i:], m.SchemaUrl) - i = encodeVarintMetrics(dAtA, i, uint64(len(m.SchemaUrl))) - i-- - dAtA[i] = 0x1a - } - if len(m.Metrics) > 0 { - for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Metrics[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintMetrics(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - { - size, err := m.InstrumentationLibrary.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintMetrics(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - func (m *Metric) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2899,9 +2719,9 @@ func (m *HistogramDataPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) { } if len(m.ExplicitBounds) > 0 { for iNdEx := len(m.ExplicitBounds) - 1; iNdEx >= 0; iNdEx-- { - f9 := math.Float64bits(float64(m.ExplicitBounds[iNdEx])) + f8 := math.Float64bits(float64(m.ExplicitBounds[iNdEx])) i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f9)) + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f8)) } i = encodeVarintMetrics(dAtA, i, uint64(len(m.ExplicitBounds)*8)) i-- @@ -3177,20 +2997,20 @@ func (m *ExponentialHistogramDataPoint_Buckets) MarshalToSizedBuffer(dAtA []byte var l int _ = l if len(m.BucketCounts) > 0 { - dAtA13 := make([]byte, len(m.BucketCounts)*10) - var j12 int + dAtA12 := make([]byte, len(m.BucketCounts)*10) + var j11 int for _, num := range m.BucketCounts { for num >= 1<<7 { - dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80) + dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j12++ + j11++ } - dAtA13[j12] = uint8(num) - j12++ + dAtA12[j11] = uint8(num) + j11++ } - i -= j12 - copy(dAtA[i:], dAtA13[:j12]) - i = encodeVarintMetrics(dAtA, i, uint64(j12)) + i -= j11 + copy(dAtA[i:], dAtA12[:j11]) + i = encodeVarintMetrics(dAtA, i, uint64(j11)) i-- dAtA[i] = 0x12 } @@ -3459,12 +3279,6 @@ func (m *ResourceMetrics) Size() (n int) { if l > 0 { n += 1 + l + sovMetrics(uint64(l)) } - if len(m.InstrumentationLibraryMetrics) > 0 { - for _, e := range m.InstrumentationLibraryMetrics { - l = e.Size() - n += 2 + l + sovMetrics(uint64(l)) - } - } return n } @@ -3489,27 +3303,6 @@ func (m *ScopeMetrics) Size() (n int) { return n } -func (m *InstrumentationLibraryMetrics) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.InstrumentationLibrary.Size() - n += 1 + l + sovMetrics(uint64(l)) - if len(m.Metrics) > 0 { - for _, e := range m.Metrics { - l = e.Size() - n += 1 + l + sovMetrics(uint64(l)) - } - } - l = len(m.SchemaUrl) - if l > 0 { - n += 1 + l + sovMetrics(uint64(l)) - } - return n -} - func (m *Metric) Size() (n int) { if m == nil { return 0 @@ -4218,40 +4011,6 @@ func (m *ResourceMetrics) Unmarshal(dAtA []byte) error { } m.SchemaUrl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 1000: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InstrumentationLibraryMetrics", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMetrics - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthMetrics - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthMetrics - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.InstrumentationLibraryMetrics = append(m.InstrumentationLibraryMetrics, &InstrumentationLibraryMetrics{}) - if err := m.InstrumentationLibraryMetrics[len(m.InstrumentationLibraryMetrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMetrics(dAtA[iNdEx:]) @@ -4422,155 +4181,6 @@ func (m *ScopeMetrics) Unmarshal(dAtA []byte) error { } return nil } -func (m *InstrumentationLibraryMetrics) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMetrics - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: InstrumentationLibraryMetrics: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: InstrumentationLibraryMetrics: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InstrumentationLibrary", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMetrics - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthMetrics - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthMetrics - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.InstrumentationLibrary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMetrics - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthMetrics - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthMetrics - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Metrics = append(m.Metrics, &Metric{}) - if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SchemaUrl", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMetrics - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthMetrics - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthMetrics - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SchemaUrl = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipMetrics(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthMetrics - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *Metric) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/pdata/internal/data/protogen/resource/v1/resource.pb.go b/pdata/internal/data/protogen/resource/v1/resource.pb.go index 7463b483e4d..d4d1565c764 100644 --- a/pdata/internal/data/protogen/resource/v1/resource.pb.go +++ b/pdata/internal/data/protogen/resource/v1/resource.pb.go @@ -93,7 +93,7 @@ func init() { } var fileDescriptor_446f73eacf88f3f5 = []byte{ - // 284 bytes of a gzipped FileDescriptorProto + // 302 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xcb, 0x2f, 0x48, 0xcd, 0x2b, 0x49, 0xcd, 0x49, 0xcd, 0x4d, 0x2d, 0x29, 0xaa, 0xd4, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0xd7, 0x2f, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5, 0x2f, 0x33, 0x84, 0xb3, 0xf5, 0xc0, 0x52, @@ -105,13 +105,14 @@ var fileDescriptor_446f73eacf88f3f5 = []byte{ 0x95, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x21, 0x19, 0x20, 0x64, 0xc1, 0x25, 0x91, 0x52, 0x94, 0x5f, 0x50, 0x90, 0x9a, 0x12, 0x8f, 0x10, 0x8d, 0x4f, 0xce, 0x2f, 0xcd, 0x2b, 0x91, 0x60, 0x52, 0x60, 0xd4, 0xe0, 0x0d, 0x12, 0x83, 0xca, 0x3b, 0xc2, 0xa5, - 0x9d, 0x41, 0xb2, 0x4e, 0x53, 0x19, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, + 0x9d, 0x41, 0xb2, 0x4e, 0xdb, 0x19, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x81, 0x4b, 0x29, 0x33, 0x5f, 0x8f, 0x40, 0xb0, 0x38, 0xf1, 0xc2, 0x7c, 0x14, 0x00, 0x92, 0x0a, 0x60, 0x8c, 0x72, 0x4b, 0x47, 0xd7, 0x94, 0x09, 0x0a, 0x91, 0x9c, 0x9c, 0xd4, 0xe4, 0x92, 0xfc, 0x22, 0xfd, 0x82, 0x94, 0xc4, 0x92, 0x44, 0xfd, 0xcc, 0xbc, 0x92, 0xd4, 0xa2, 0xbc, 0xc4, 0x1c, 0x7d, - 0x30, 0x0f, 0x6c, 0x6a, 0x7a, 0x6a, 0x1e, 0x72, 0xfc, 0x24, 0xb1, 0x81, 0x45, 0x8d, 0x01, 0x01, - 0x00, 0x00, 0xff, 0xff, 0x9e, 0x31, 0xb9, 0x5c, 0xc9, 0x01, 0x00, 0x00, + 0x30, 0x0f, 0x6c, 0x6a, 0x7a, 0x6a, 0x1e, 0x72, 0xfc, 0xac, 0x62, 0x92, 0xf7, 0x2f, 0x48, 0xcd, + 0x0b, 0x81, 0x9b, 0x02, 0x36, 0x5f, 0x0f, 0x66, 0x9b, 0x5e, 0x98, 0x61, 0x12, 0x1b, 0x58, 0x9f, + 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xbd, 0x8b, 0xcf, 0x38, 0xeb, 0x01, 0x00, 0x00, } func (m *Resource) Marshal() (dAtA []byte, err error) { diff --git a/pdata/internal/data/protogen/trace/v1/trace.pb.go b/pdata/internal/data/protogen/trace/v1/trace.pb.go index 8f41776db5a..db297476ad6 100644 --- a/pdata/internal/data/protogen/trace/v1/trace.pb.go +++ b/pdata/internal/data/protogen/trace/v1/trace.pb.go @@ -79,7 +79,7 @@ func (x Span_SpanKind) String() string { } func (Span_SpanKind) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_5c407ac9c675a601, []int{4, 0} + return fileDescriptor_5c407ac9c675a601, []int{3, 0} } // For the semantics of status codes see @@ -113,7 +113,7 @@ func (x Status_StatusCode) String() string { } func (Status_StatusCode) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_5c407ac9c675a601, []int{5, 0} + return fileDescriptor_5c407ac9c675a601, []int{4, 0} } // TracesData represents the traces data that can be stored in a persistent storage, @@ -182,34 +182,6 @@ type ResourceSpans struct { Resource v1.Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource"` // A list of ScopeSpans that originate from a resource. ScopeSpans []*ScopeSpans `protobuf:"bytes,2,rep,name=scope_spans,json=scopeSpans,proto3" json:"scope_spans,omitempty"` - // A list of InstrumentationLibrarySpans that originate from a resource. - // This field is deprecated and will be removed after grace period expires on June 15, 2022. - // - // During the grace period the following rules SHOULD be followed: - // - // For Binary Protobufs - // ==================== - // Binary Protobuf senders SHOULD NOT set instrumentation_library_spans. Instead - // scope_spans SHOULD be set. - // - // Binary Protobuf receivers SHOULD check if instrumentation_library_spans is set - // and scope_spans is not set then the value in instrumentation_library_spans - // SHOULD be used instead by converting InstrumentationLibrarySpans into ScopeSpans. - // If scope_spans is set then instrumentation_library_spans SHOULD be ignored. - // - // For JSON - // ======== - // JSON senders that set instrumentation_library_spans field MAY also set - // scope_spans to carry the same spans, essentially double-publishing the same data. - // Such double-publishing MAY be controlled by a user-settable option. - // If double-publishing is not used then the senders SHOULD set scope_spans and - // SHOULD NOT set instrumentation_library_spans. - // - // JSON receivers SHOULD check if instrumentation_library_spans is set and - // scope_spans is not set then the value in instrumentation_library_spans - // SHOULD be used instead by converting InstrumentationLibrarySpans into ScopeSpans. - // If scope_spans is set then instrumentation_library_spans field SHOULD be ignored. - InstrumentationLibrarySpans []*InstrumentationLibrarySpans `protobuf:"bytes,1000,rep,name=instrumentation_library_spans,json=instrumentationLibrarySpans,proto3" json:"instrumentation_library_spans,omitempty"` // Deprecated: Do not use. // 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. SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` @@ -262,14 +234,6 @@ func (m *ResourceSpans) GetScopeSpans() []*ScopeSpans { return nil } -// Deprecated: Do not use. -func (m *ResourceSpans) GetInstrumentationLibrarySpans() []*InstrumentationLibrarySpans { - if m != nil { - return m.InstrumentationLibrarySpans - } - return nil -} - func (m *ResourceSpans) GetSchemaUrl() string { if m != nil { return m.SchemaUrl @@ -343,84 +307,7 @@ func (m *ScopeSpans) GetSchemaUrl() string { return "" } -// A collection of Spans produced by an InstrumentationLibrary. -// InstrumentationLibrarySpans is wire-compatible with ScopeSpans for binary -// Protobuf format. -// This message is deprecated and will be removed on June 15, 2022. -// -// Deprecated: Do not use. -type InstrumentationLibrarySpans struct { - // The instrumentation library information for the spans in this message. - // Semantically when InstrumentationLibrary isn't set, it is equivalent with - // an empty instrumentation library name (unknown). - InstrumentationLibrary v11.InstrumentationLibrary `protobuf:"bytes,1,opt,name=instrumentation_library,json=instrumentationLibrary,proto3" json:"instrumentation_library"` - // A list of Spans that originate from an instrumentation library. - Spans []*Span `protobuf:"bytes,2,rep,name=spans,proto3" json:"spans,omitempty"` - // This schema_url applies to all spans and span events in the "spans" field. - SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` -} - -func (m *InstrumentationLibrarySpans) Reset() { *m = InstrumentationLibrarySpans{} } -func (m *InstrumentationLibrarySpans) String() string { return proto.CompactTextString(m) } -func (*InstrumentationLibrarySpans) ProtoMessage() {} -func (*InstrumentationLibrarySpans) Descriptor() ([]byte, []int) { - return fileDescriptor_5c407ac9c675a601, []int{3} -} -func (m *InstrumentationLibrarySpans) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *InstrumentationLibrarySpans) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_InstrumentationLibrarySpans.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *InstrumentationLibrarySpans) XXX_Merge(src proto.Message) { - xxx_messageInfo_InstrumentationLibrarySpans.Merge(m, src) -} -func (m *InstrumentationLibrarySpans) XXX_Size() int { - return m.Size() -} -func (m *InstrumentationLibrarySpans) XXX_DiscardUnknown() { - xxx_messageInfo_InstrumentationLibrarySpans.DiscardUnknown(m) -} - -var xxx_messageInfo_InstrumentationLibrarySpans proto.InternalMessageInfo - -func (m *InstrumentationLibrarySpans) GetInstrumentationLibrary() v11.InstrumentationLibrary { - if m != nil { - return m.InstrumentationLibrary - } - return v11.InstrumentationLibrary{} -} - -func (m *InstrumentationLibrarySpans) GetSpans() []*Span { - if m != nil { - return m.Spans - } - return nil -} - -func (m *InstrumentationLibrarySpans) GetSchemaUrl() string { - if m != nil { - return m.SchemaUrl - } - return "" -} - -// Span represents a single operation within a trace. Spans can be -// nested to form a trace tree. Spans may also be linked to other spans -// from the same or different trace and form graphs. Often, a trace -// contains a root span that describes the end-to-end latency, and one -// or more subspans for its sub-operations. A trace can also contain -// multiple root spans, or none at all. Spans do not need to be -// contiguous - there may be gaps or overlaps between spans in a trace. +// A Span represents a single operation performed by a single component of the system. // // The next available field id is 17. type Span struct { @@ -488,7 +375,7 @@ type Span struct { // "abc.com/score": 10.239 // // The OpenTelemetry API specification further restricts the allowed value types: - // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/common/common.md#attributes + // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/common/README.md#attribute // Attribute keys MUST be unique (it is not allowed to have more than one // attribute with the same key). Attributes []v11.KeyValue `protobuf:"bytes,9,rep,name=attributes,proto3" json:"attributes"` @@ -516,7 +403,7 @@ func (m *Span) Reset() { *m = Span{} } func (m *Span) String() string { return proto.CompactTextString(m) } func (*Span) ProtoMessage() {} func (*Span) Descriptor() ([]byte, []int) { - return fileDescriptor_5c407ac9c675a601, []int{4} + return fileDescriptor_5c407ac9c675a601, []int{3} } func (m *Span) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -650,7 +537,7 @@ func (m *Span_Event) Reset() { *m = Span_Event{} } func (m *Span_Event) String() string { return proto.CompactTextString(m) } func (*Span_Event) ProtoMessage() {} func (*Span_Event) Descriptor() ([]byte, []int) { - return fileDescriptor_5c407ac9c675a601, []int{4, 0} + return fileDescriptor_5c407ac9c675a601, []int{3, 0} } func (m *Span_Event) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -732,7 +619,7 @@ func (m *Span_Link) Reset() { *m = Span_Link{} } func (m *Span_Link) String() string { return proto.CompactTextString(m) } func (*Span_Link) ProtoMessage() {} func (*Span_Link) Descriptor() ([]byte, []int) { - return fileDescriptor_5c407ac9c675a601, []int{4, 1} + return fileDescriptor_5c407ac9c675a601, []int{3, 1} } func (m *Span_Link) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -795,7 +682,7 @@ func (m *Status) Reset() { *m = Status{} } func (m *Status) String() string { return proto.CompactTextString(m) } func (*Status) ProtoMessage() {} func (*Status) Descriptor() ([]byte, []int) { - return fileDescriptor_5c407ac9c675a601, []int{5} + return fileDescriptor_5c407ac9c675a601, []int{4} } func (m *Status) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -844,7 +731,6 @@ func init() { proto.RegisterType((*TracesData)(nil), "opentelemetry.proto.trace.v1.TracesData") proto.RegisterType((*ResourceSpans)(nil), "opentelemetry.proto.trace.v1.ResourceSpans") proto.RegisterType((*ScopeSpans)(nil), "opentelemetry.proto.trace.v1.ScopeSpans") - proto.RegisterType((*InstrumentationLibrarySpans)(nil), "opentelemetry.proto.trace.v1.InstrumentationLibrarySpans") proto.RegisterType((*Span)(nil), "opentelemetry.proto.trace.v1.Span") proto.RegisterType((*Span_Event)(nil), "opentelemetry.proto.trace.v1.Span.Event") proto.RegisterType((*Span_Link)(nil), "opentelemetry.proto.trace.v1.Span.Link") @@ -856,72 +742,70 @@ func init() { } var fileDescriptor_5c407ac9c675a601 = []byte{ - // 1040 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x56, 0xcf, 0x6f, 0x1b, 0x45, - 0x14, 0xf6, 0x38, 0x6b, 0x27, 0x79, 0x49, 0xdc, 0xcd, 0x90, 0x86, 0x25, 0xa5, 0x8e, 0x65, 0x55, - 0xc2, 0x50, 0xc9, 0xa6, 0xa9, 0x90, 0x52, 0x24, 0x44, 0x63, 0x7b, 0x91, 0x96, 0xa4, 0x76, 0x34, - 0xb6, 0x2b, 0x81, 0x90, 0x96, 0x8d, 0x77, 0x08, 0xab, 0xd8, 0xb3, 0xd6, 0xee, 0x38, 0x6a, 0x6e, - 0x88, 0x33, 0x07, 0xae, 0xfc, 0x23, 0xdc, 0xb8, 0x57, 0x70, 0xe9, 0x11, 0x71, 0xa8, 0x50, 0x72, - 0x81, 0x1b, 0x7f, 0x02, 0x9a, 0x1f, 0x9b, 0x78, 0x43, 0x6a, 0x37, 0x12, 0xb9, 0xf4, 0x62, 0xcf, - 0xbe, 0x1f, 0xdf, 0xfb, 0xde, 0x37, 0x6f, 0x46, 0x03, 0x95, 0x70, 0x44, 0x19, 0xa7, 0x03, 0x3a, - 0xa4, 0x3c, 0x3a, 0xa9, 0x8d, 0xa2, 0x90, 0x87, 0x35, 0x1e, 0x79, 0x7d, 0x5a, 0x3b, 0x7e, 0xa0, - 0x16, 0x55, 0x69, 0xc4, 0xef, 0xa6, 0x22, 0x95, 0xb1, 0xaa, 0x02, 0x8e, 0x1f, 0x6c, 0xac, 0x1d, - 0x86, 0x87, 0xa1, 0xca, 0x16, 0x2b, 0xe5, 0xde, 0xf8, 0xe0, 0x2a, 0xf4, 0x7e, 0x38, 0x1c, 0x86, - 0x4c, 0xc0, 0xab, 0x95, 0x8e, 0xad, 0x5e, 0x15, 0x1b, 0xd1, 0x38, 0x1c, 0x47, 0x8a, 0x4c, 0xb2, - 0x56, 0xf1, 0xe5, 0xaf, 0x01, 0xba, 0xa2, 0x7a, 0xdc, 0xf4, 0xb8, 0x87, 0x09, 0x14, 0x12, 0xbf, - 0x1b, 0x8f, 0x3c, 0x16, 0x5b, 0xa8, 0x34, 0x57, 0x59, 0xda, 0xba, 0x5f, 0x9d, 0x46, 0xbb, 0x4a, - 0x74, 0x4e, 0x47, 0xa4, 0x90, 0x95, 0x68, 0xf2, 0xb3, 0xfc, 0x5b, 0x16, 0x56, 0x52, 0x01, 0x78, - 0x17, 0x16, 0x92, 0x10, 0x0b, 0x95, 0x50, 0x65, 0x69, 0xeb, 0xfd, 0x2b, 0xf1, 0xcf, 0xa9, 0x4e, - 0x94, 0xa8, 0x1b, 0xcf, 0x5f, 0x6e, 0x66, 0xc8, 0x39, 0x00, 0x76, 0x60, 0x29, 0xee, 0x87, 0xa3, - 0x84, 0x6f, 0x56, 0xf2, 0xad, 0x4c, 0xe7, 0xdb, 0x11, 0x09, 0x8a, 0x2c, 0xc4, 0xe7, 0x6b, 0xfc, - 0x3d, 0x82, 0xbb, 0x01, 0x8b, 0x79, 0x34, 0x1e, 0x52, 0xc6, 0x3d, 0x1e, 0x84, 0xcc, 0x1d, 0x04, - 0x07, 0x91, 0x17, 0x9d, 0x68, 0xf4, 0xbf, 0xe6, 0x25, 0xfc, 0xa3, 0xe9, 0xf0, 0x4e, 0x1a, 0x63, - 0x4f, 0x41, 0xc8, 0x1a, 0xf5, 0xac, 0x85, 0xc8, 0x9d, 0xe0, 0xd5, 0x01, 0xf8, 0x2e, 0x40, 0xdc, - 0xff, 0x96, 0x0e, 0x3d, 0x77, 0x1c, 0x0d, 0xac, 0xb9, 0x12, 0xaa, 0x2c, 0x92, 0x45, 0x65, 0xe9, - 0x45, 0x83, 0xf2, 0xcf, 0x08, 0xe0, 0x82, 0x3e, 0x6e, 0x43, 0x4e, 0x36, 0xa0, 0x75, 0x7c, 0x78, - 0x25, 0x31, 0x3d, 0x20, 0xff, 0x65, 0x26, 0x81, 0xb4, 0xa2, 0x0a, 0x07, 0x6f, 0x43, 0x6e, 0x52, - 0xc8, 0xf2, 0x0c, 0x21, 0x47, 0x1e, 0x23, 0x2a, 0x61, 0x16, 0xf1, 0x7f, 0x10, 0xdc, 0x99, 0x22, - 0x0c, 0xe6, 0xf0, 0xf6, 0x2b, 0xb4, 0xd7, 0xbd, 0x7d, 0x74, 0xbd, 0xde, 0x34, 0xb8, 0xee, 0x6e, - 0xfd, 0x6a, 0xc9, 0x6f, 0xac, 0xdd, 0x8f, 0xb3, 0x16, 0x2a, 0x7f, 0xb7, 0x02, 0x86, 0x48, 0xc1, - 0x5f, 0xc1, 0x82, 0xc4, 0x70, 0x03, 0x5f, 0x36, 0xb3, 0x5c, 0xdf, 0x11, 0xac, 0xfe, 0x78, 0xb9, - 0xf9, 0xe8, 0x30, 0xbc, 0x54, 0x32, 0x10, 0x47, 0x7b, 0x30, 0xa0, 0x7d, 0x1e, 0x46, 0xb5, 0x91, - 0xef, 0x71, 0xaf, 0x16, 0x30, 0x4e, 0x23, 0xe6, 0x0d, 0x6a, 0xe2, 0xab, 0x2a, 0x8f, 0xab, 0xd3, - 0x24, 0xf3, 0x12, 0xd2, 0xf1, 0xf1, 0x17, 0x30, 0x2f, 0x28, 0x09, 0xf0, 0xac, 0x04, 0x7f, 0xac, - 0xc1, 0xb7, 0xaf, 0x0f, 0x2e, 0xe8, 0x3a, 0x4d, 0x92, 0x17, 0x80, 0x8e, 0x8f, 0x37, 0x61, 0x49, - 0x11, 0x8f, 0xb9, 0xc7, 0xa9, 0xee, 0x12, 0xa4, 0xa9, 0x23, 0x2c, 0xf8, 0x1b, 0x28, 0x8c, 0xbc, - 0x88, 0x32, 0xee, 0x26, 0x14, 0x8c, 0xff, 0x89, 0xc2, 0xb2, 0xc2, 0xed, 0x28, 0x22, 0x18, 0x0c, - 0xe6, 0x0d, 0xa9, 0x95, 0x93, 0x0c, 0xe4, 0x1a, 0x7f, 0x0a, 0xc6, 0x51, 0xc0, 0x7c, 0x2b, 0x5f, - 0x42, 0x95, 0xc2, 0xac, 0x2b, 0x4a, 0xe0, 0xc8, 0x9f, 0xdd, 0x80, 0xf9, 0x44, 0x26, 0xe2, 0x1a, - 0xac, 0xc5, 0xdc, 0x8b, 0xb8, 0xcb, 0x83, 0x21, 0x75, 0xc7, 0x2c, 0x78, 0xe6, 0x32, 0x8f, 0x85, - 0xd6, 0x7c, 0x09, 0x55, 0xf2, 0x64, 0x55, 0xfa, 0xba, 0xc1, 0x90, 0xf6, 0x58, 0xf0, 0xac, 0xe5, - 0xb1, 0x10, 0xdf, 0x07, 0x4c, 0x99, 0x7f, 0x39, 0x7c, 0x41, 0x86, 0xdf, 0xa2, 0xcc, 0x4f, 0x05, - 0x3f, 0x01, 0xf0, 0x38, 0x8f, 0x82, 0x83, 0x31, 0xa7, 0xb1, 0xb5, 0x28, 0xe7, 0xeb, 0xbd, 0x19, - 0x33, 0xbc, 0x4b, 0x4f, 0x9e, 0x7a, 0x83, 0x71, 0x72, 0x26, 0x27, 0x00, 0xf0, 0x36, 0x58, 0x7e, - 0x14, 0x8e, 0x46, 0xd4, 0x77, 0x2f, 0xac, 0x6e, 0x3f, 0x1c, 0x33, 0x6e, 0x41, 0x09, 0x55, 0x56, - 0xc8, 0xba, 0xf6, 0xef, 0x9c, 0xbb, 0x1b, 0xc2, 0x8b, 0x1f, 0x43, 0x9e, 0x1e, 0x53, 0xc6, 0x63, - 0x6b, 0xe9, 0xb5, 0x2e, 0x47, 0xa1, 0x94, 0x2d, 0x12, 0x88, 0xce, 0xc3, 0x1f, 0xc2, 0x5a, 0x52, - 0x5b, 0x59, 0x74, 0xdd, 0x65, 0x59, 0x17, 0x6b, 0x9f, 0xcc, 0xd1, 0x35, 0x3f, 0x81, 0xdc, 0x20, - 0x60, 0x47, 0xb1, 0xb5, 0x32, 0xa5, 0xef, 0x74, 0xc9, 0xbd, 0x80, 0x1d, 0x11, 0x95, 0x85, 0xab, - 0xf0, 0x56, 0x52, 0x50, 0x1a, 0x74, 0xbd, 0x82, 0xac, 0xb7, 0xaa, 0x5d, 0x22, 0x41, 0x97, 0xab, - 0x43, 0x5e, 0x4c, 0xe8, 0x38, 0xb6, 0x6e, 0xc9, 0xbb, 0xe2, 0xde, 0x8c, 0x7a, 0x32, 0x56, 0x8b, - 0xac, 0x33, 0x37, 0x7e, 0x45, 0x90, 0x93, 0x2d, 0xe0, 0x7b, 0x50, 0xb8, 0xb4, 0xc5, 0x48, 0x6e, - 0xf1, 0x32, 0x9f, 0xdc, 0xdf, 0x64, 0x24, 0xb3, 0x13, 0x23, 0x99, 0xde, 0xf3, 0xb9, 0x9b, 0xdc, - 0x73, 0x63, 0xda, 0x9e, 0x6f, 0xfc, 0x9d, 0x05, 0x43, 0xe8, 0xf3, 0x06, 0x5f, 0x3d, 0x69, 0xad, - 0x8d, 0x9b, 0xd4, 0x3a, 0x37, 0x4d, 0xeb, 0xf2, 0x4f, 0x08, 0x16, 0x92, 0x9b, 0x05, 0xbf, 0x03, - 0xb7, 0x3b, 0xfb, 0x3b, 0x2d, 0x77, 0xd7, 0x69, 0x35, 0xdd, 0x5e, 0xab, 0xb3, 0x6f, 0x37, 0x9c, - 0xcf, 0x1c, 0xbb, 0x69, 0x66, 0xf0, 0x3a, 0xe0, 0x0b, 0x97, 0xd3, 0xea, 0xda, 0xa4, 0xb5, 0xb3, - 0x67, 0x22, 0xbc, 0x06, 0xe6, 0x85, 0xbd, 0x63, 0x93, 0xa7, 0x36, 0x31, 0xb3, 0x69, 0x6b, 0x63, - 0xcf, 0xb1, 0x5b, 0x5d, 0x73, 0x2e, 0x8d, 0xb1, 0x4f, 0xda, 0xcd, 0x5e, 0xc3, 0x26, 0xa6, 0x91, - 0xb6, 0x37, 0xda, 0xad, 0x4e, 0xef, 0x89, 0x4d, 0xcc, 0x5c, 0xf9, 0x17, 0x04, 0x79, 0x35, 0xed, - 0xd8, 0x82, 0xf9, 0x21, 0x8d, 0x63, 0xef, 0x30, 0x19, 0xd9, 0xe4, 0x13, 0x37, 0xc0, 0xe8, 0x87, - 0xbe, 0xd2, 0xb8, 0xb0, 0x55, 0x7b, 0x9d, 0xb3, 0xa3, 0xff, 0x1a, 0xa1, 0x4f, 0x89, 0x4c, 0x2e, - 0xb7, 0x00, 0x2e, 0x6c, 0xf8, 0x36, 0xac, 0x76, 0xba, 0x3b, 0xdd, 0x5e, 0xc7, 0x6d, 0xb4, 0x9b, - 0xb6, 0x10, 0xc2, 0xee, 0x9a, 0x19, 0x8c, 0xa1, 0x30, 0x69, 0x6e, 0xef, 0x9a, 0xe8, 0x72, 0xa8, - 0x4d, 0x48, 0x9b, 0x98, 0xd9, 0xcf, 0x8d, 0x05, 0x64, 0x66, 0xeb, 0x3f, 0xa0, 0xe7, 0xa7, 0x45, - 0xf4, 0xe2, 0xb4, 0x88, 0xfe, 0x3c, 0x2d, 0xa2, 0x1f, 0xcf, 0x8a, 0x99, 0x17, 0x67, 0xc5, 0xcc, - 0xef, 0x67, 0xc5, 0x0c, 0x6c, 0x06, 0xe1, 0x54, 0xa6, 0x75, 0xf5, 0xb0, 0xdd, 0x17, 0xc6, 0x7d, - 0xf4, 0x65, 0xe3, 0xda, 0x13, 0xa9, 0x1e, 0xcf, 0x87, 0x94, 0x9d, 0xbf, 0xe4, 0x0f, 0xf2, 0xd2, - 0xf4, 0xf0, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x56, 0xa5, 0xef, 0x0c, 0xf0, 0x0b, 0x00, 0x00, + // 996 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x56, 0x4d, 0x6f, 0xdb, 0x46, + 0x13, 0xd6, 0xca, 0xd4, 0x87, 0xc7, 0xb6, 0x42, 0xef, 0xeb, 0x04, 0x7c, 0x8d, 0x54, 0x16, 0x84, + 0x00, 0x55, 0x1b, 0x40, 0xaa, 0x9d, 0x8b, 0x7b, 0x28, 0x1a, 0x5b, 0x62, 0x01, 0x46, 0x8e, 0x24, + 0x2c, 0x25, 0x03, 0x2d, 0x0a, 0xb0, 0x8c, 0xb8, 0x55, 0x09, 0x4b, 0x4b, 0x82, 0x5c, 0x19, 0xc9, + 0xad, 0x3f, 0xa1, 0xd7, 0xfe, 0x85, 0xf6, 0xde, 0x5b, 0xef, 0x41, 0x0f, 0x45, 0x8e, 0x45, 0x0f, + 0x41, 0x61, 0x5f, 0x9a, 0x7f, 0x51, 0xec, 0x2e, 0xa9, 0x0f, 0xc3, 0x90, 0x12, 0xa0, 0xb9, 0xf4, + 0x22, 0x2d, 0x67, 0xe6, 0x79, 0xe6, 0x99, 0x8f, 0x25, 0x08, 0xb5, 0x20, 0xa4, 0x8c, 0xd3, 0x31, + 0x9d, 0x50, 0x1e, 0xbd, 0x68, 0x84, 0x51, 0xc0, 0x83, 0x06, 0x8f, 0xdc, 0x21, 0x6d, 0x5c, 0x1e, + 0xaa, 0x43, 0x5d, 0x1a, 0xf1, 0xfd, 0xa5, 0x48, 0x65, 0xac, 0xab, 0x80, 0xcb, 0xc3, 0xfd, 0xbd, + 0x51, 0x30, 0x0a, 0x14, 0x5a, 0x9c, 0x94, 0x7b, 0xff, 0xe3, 0xdb, 0xd8, 0x87, 0xc1, 0x64, 0x12, + 0x30, 0x41, 0xaf, 0x4e, 0x49, 0x6c, 0xfd, 0xb6, 0xd8, 0x88, 0xc6, 0xc1, 0x34, 0x52, 0x62, 0xd2, + 0xb3, 0x8a, 0xaf, 0x7e, 0x03, 0xd0, 0x17, 0xd9, 0xe3, 0x96, 0xcb, 0x5d, 0x4c, 0xa0, 0x94, 0xfa, + 0x9d, 0x38, 0x74, 0x59, 0x6c, 0xa0, 0xca, 0x46, 0x6d, 0xeb, 0xe8, 0x61, 0x7d, 0x95, 0xec, 0x3a, + 0x49, 0x30, 0xb6, 0x80, 0x90, 0x9d, 0x68, 0xf1, 0xb1, 0xfa, 0x3b, 0x82, 0x9d, 0xa5, 0x00, 0xdc, + 0x86, 0x62, 0x1a, 0x62, 0xa0, 0x0a, 0xaa, 0x6d, 0x1d, 0x7d, 0x74, 0x2b, 0xff, 0x4c, 0xea, 0x42, + 0x8a, 0x53, 0xed, 0xe5, 0xeb, 0x83, 0x0c, 0x99, 0x11, 0x60, 0x0b, 0xb6, 0xe2, 0x61, 0x10, 0xa6, + 0x7a, 0xb3, 0x52, 0x6f, 0x6d, 0xb5, 0x5e, 0x5b, 0x00, 0x94, 0x58, 0x88, 0x67, 0x67, 0xfc, 0x01, + 0x40, 0x3c, 0xfc, 0x8e, 0x4e, 0x5c, 0x67, 0x1a, 0x8d, 0x8d, 0x8d, 0x0a, 0xaa, 0x6d, 0x92, 0x4d, + 0x65, 0x19, 0x44, 0xe3, 0x27, 0xf9, 0xe2, 0xdf, 0x05, 0xfd, 0x4d, 0xa1, 0xfa, 0x0b, 0x02, 0x98, + 0x33, 0xe0, 0x2e, 0xe4, 0x24, 0x47, 0x52, 0xca, 0xa3, 0x5b, 0x53, 0x27, 0x33, 0xba, 0x3c, 0xac, + 0x5b, 0x2c, 0xe6, 0xd1, 0x74, 0x42, 0x19, 0x77, 0xb9, 0x1f, 0x30, 0x49, 0x94, 0x14, 0xa5, 0x78, + 0xf0, 0x31, 0xe4, 0x16, 0x6b, 0xa9, 0xae, 0xa9, 0x25, 0x74, 0x19, 0x51, 0x80, 0x35, 0x05, 0x54, + 0xbf, 0xdf, 0x01, 0x4d, 0x84, 0xe3, 0xaf, 0xa1, 0x28, 0xf1, 0x8e, 0xef, 0x49, 0xd5, 0xdb, 0xa7, + 0x27, 0x42, 0xc0, 0x9f, 0xaf, 0x0f, 0x3e, 0x1d, 0x05, 0x37, 0xd2, 0xf9, 0x62, 0xd5, 0xc6, 0x63, + 0x3a, 0xe4, 0x41, 0xd4, 0x08, 0x3d, 0x97, 0xbb, 0x0d, 0x9f, 0x71, 0x1a, 0x31, 0x77, 0xdc, 0x10, + 0x4f, 0x75, 0xb9, 0x3e, 0x56, 0x8b, 0x14, 0x24, 0xa5, 0xe5, 0xe1, 0x2f, 0xa1, 0x20, 0xe4, 0x08, + 0xf2, 0xac, 0x24, 0x7f, 0x9c, 0x90, 0x1f, 0xbf, 0x3b, 0xb9, 0x90, 0x6b, 0xb5, 0x48, 0x5e, 0x10, + 0x5a, 0x1e, 0x3e, 0x80, 0x2d, 0x25, 0x3c, 0xe6, 0x2e, 0xa7, 0x49, 0x85, 0x20, 0x4d, 0xb6, 0xb0, + 0xe0, 0x6f, 0xa1, 0x14, 0xba, 0x11, 0x65, 0xdc, 0x49, 0x25, 0x68, 0xff, 0x92, 0x84, 0x6d, 0xc5, + 0x6b, 0x2b, 0x21, 0x18, 0x34, 0xe6, 0x4e, 0xa8, 0x91, 0x93, 0x0a, 0xe4, 0x19, 0x7f, 0x0e, 0xda, + 0x85, 0xcf, 0x3c, 0x23, 0x5f, 0x41, 0xb5, 0xd2, 0xba, 0x2b, 0x23, 0x78, 0xe4, 0x4f, 0xdb, 0x67, + 0x1e, 0x91, 0x40, 0xdc, 0x80, 0xbd, 0x98, 0xbb, 0x11, 0x77, 0xb8, 0x3f, 0xa1, 0xce, 0x94, 0xf9, + 0xcf, 0x1d, 0xe6, 0xb2, 0xc0, 0x28, 0x54, 0x50, 0x2d, 0x4f, 0x76, 0xa5, 0xaf, 0xef, 0x4f, 0xe8, + 0x80, 0xf9, 0xcf, 0x3b, 0x2e, 0x0b, 0xf0, 0x43, 0xc0, 0x94, 0x79, 0x37, 0xc3, 0x8b, 0x32, 0xfc, + 0x0e, 0x65, 0xde, 0x52, 0xf0, 0x53, 0x00, 0x97, 0xf3, 0xc8, 0x7f, 0x36, 0xe5, 0x34, 0x36, 0x36, + 0xe5, 0x6e, 0x7d, 0xb8, 0x66, 0x59, 0xdb, 0xf4, 0xc5, 0xb9, 0x3b, 0x9e, 0xa6, 0x0b, 0xba, 0x40, + 0x80, 0x8f, 0xc1, 0xf0, 0xa2, 0x20, 0x0c, 0xa9, 0xe7, 0xcc, 0xad, 0xce, 0x30, 0x98, 0x32, 0x6e, + 0x40, 0x05, 0xd5, 0x76, 0xc8, 0xbd, 0xc4, 0x7f, 0x32, 0x73, 0x37, 0x85, 0x17, 0x3f, 0x86, 0x3c, + 0xbd, 0xa4, 0x8c, 0xc7, 0xc6, 0xd6, 0x5b, 0x5d, 0x56, 0xd1, 0x29, 0x53, 0x00, 0x48, 0x82, 0xc3, + 0x9f, 0xc0, 0x5e, 0x9a, 0x5b, 0x59, 0x92, 0xbc, 0xdb, 0x32, 0x2f, 0x4e, 0x7c, 0x12, 0x93, 0xe4, + 0xfc, 0x0c, 0x72, 0x63, 0x9f, 0x5d, 0xc4, 0xc6, 0xce, 0x8a, 0xba, 0x97, 0x53, 0x9e, 0xf9, 0xec, + 0x82, 0x28, 0x14, 0xae, 0xc3, 0xff, 0xd2, 0x84, 0xd2, 0x90, 0xe4, 0x2b, 0xc9, 0x7c, 0xbb, 0x89, + 0x4b, 0x00, 0x92, 0x74, 0xa7, 0x90, 0x17, 0x1b, 0x3a, 0x8d, 0x8d, 0x3b, 0xf2, 0xa5, 0xf0, 0x60, + 0x4d, 0x3e, 0x19, 0x9b, 0x34, 0x39, 0x41, 0xee, 0xff, 0x86, 0x20, 0x27, 0x4b, 0xc0, 0x0f, 0xa0, + 0x74, 0x63, 0xc4, 0x48, 0x8e, 0x78, 0x9b, 0x2f, 0xce, 0x37, 0x5d, 0xc9, 0xec, 0xc2, 0x4a, 0x2e, + 0xcf, 0x7c, 0xe3, 0x7d, 0xce, 0x5c, 0x5b, 0x35, 0xf3, 0xfd, 0x37, 0x59, 0xd0, 0x44, 0x7f, 0xfe, + 0xc3, 0xaf, 0x9e, 0xe5, 0x5e, 0x6b, 0xef, 0xb3, 0xd7, 0xb9, 0x55, 0xbd, 0xae, 0xfe, 0x88, 0xa0, + 0x98, 0xbe, 0x59, 0xf0, 0xff, 0xe1, 0xae, 0xdd, 0x3b, 0xe9, 0x38, 0x6d, 0xab, 0xd3, 0x72, 0x06, + 0x1d, 0xbb, 0x67, 0x36, 0xad, 0x2f, 0x2c, 0xb3, 0xa5, 0x67, 0xf0, 0x3d, 0xc0, 0x73, 0x97, 0xd5, + 0xe9, 0x9b, 0xa4, 0x73, 0x72, 0xa6, 0x23, 0xbc, 0x07, 0xfa, 0xdc, 0x6e, 0x9b, 0xe4, 0xdc, 0x24, + 0x7a, 0x76, 0xd9, 0xda, 0x3c, 0xb3, 0xcc, 0x4e, 0x5f, 0xdf, 0x58, 0xe6, 0xe8, 0x91, 0x6e, 0x6b, + 0xd0, 0x34, 0x89, 0xae, 0x2d, 0xdb, 0x9b, 0xdd, 0x8e, 0x3d, 0x78, 0x6a, 0x12, 0x3d, 0x57, 0xfd, + 0x15, 0x41, 0x5e, 0x6d, 0x3b, 0x36, 0xa0, 0x30, 0xa1, 0x71, 0xec, 0x8e, 0xd2, 0x95, 0x4d, 0x1f, + 0x71, 0x13, 0xb4, 0x61, 0xe0, 0xa9, 0x1e, 0x97, 0x8e, 0x1a, 0x6f, 0x73, 0x77, 0x92, 0xbf, 0x66, + 0xe0, 0x51, 0x22, 0xc1, 0xd5, 0x0e, 0xc0, 0xdc, 0x86, 0xef, 0xc2, 0xae, 0xdd, 0x3f, 0xe9, 0x0f, + 0x6c, 0xa7, 0xd9, 0x6d, 0x99, 0xa2, 0x11, 0x66, 0x5f, 0xcf, 0x60, 0x0c, 0xa5, 0x45, 0x73, 0xb7, + 0xad, 0xa3, 0x9b, 0xa1, 0x26, 0x21, 0x5d, 0xa2, 0x67, 0x9f, 0x68, 0x45, 0xa4, 0x67, 0x4f, 0x7f, + 0x46, 0x2f, 0xaf, 0xca, 0xe8, 0xd5, 0x55, 0x19, 0xfd, 0x75, 0x55, 0x46, 0x3f, 0x5c, 0x97, 0x33, + 0xaf, 0xae, 0xcb, 0x99, 0x3f, 0xae, 0xcb, 0x19, 0x38, 0xf0, 0x83, 0x95, 0x4a, 0x4f, 0xd5, 0x87, + 0x56, 0x4f, 0x18, 0x7b, 0xe8, 0xab, 0xe6, 0x3b, 0x6f, 0xa4, 0xfa, 0x98, 0x1b, 0x51, 0x36, 0xfb, + 0xb2, 0xfc, 0x29, 0x7b, 0xbf, 0x1b, 0x52, 0xd6, 0x9f, 0x51, 0x48, 0x72, 0x75, 0x2d, 0xea, 0xe7, + 0x87, 0xcf, 0xf2, 0x12, 0xf1, 0xe8, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x86, 0x1d, 0x4a, + 0x9f, 0x0a, 0x00, 0x00, } func (m *TracesData) Marshal() (dAtA []byte, err error) { @@ -981,22 +865,6 @@ func (m *ResourceSpans) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if len(m.InstrumentationLibrarySpans) > 0 { - for iNdEx := len(m.InstrumentationLibrarySpans) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.InstrumentationLibrarySpans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTrace(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3e - i-- - dAtA[i] = 0xc2 - } - } if len(m.SchemaUrl) > 0 { i -= len(m.SchemaUrl) copy(dAtA[i:], m.SchemaUrl) @@ -1085,60 +953,6 @@ func (m *ScopeSpans) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *InstrumentationLibrarySpans) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *InstrumentationLibrarySpans) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *InstrumentationLibrarySpans) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.SchemaUrl) > 0 { - i -= len(m.SchemaUrl) - copy(dAtA[i:], m.SchemaUrl) - i = encodeVarintTrace(dAtA, i, uint64(len(m.SchemaUrl))) - i-- - dAtA[i] = 0x1a - } - if len(m.Spans) > 0 { - for iNdEx := len(m.Spans) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Spans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTrace(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - { - size, err := m.InstrumentationLibrary.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTrace(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - func (m *Span) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1493,12 +1307,6 @@ func (m *ResourceSpans) Size() (n int) { if l > 0 { n += 1 + l + sovTrace(uint64(l)) } - if len(m.InstrumentationLibrarySpans) > 0 { - for _, e := range m.InstrumentationLibrarySpans { - l = e.Size() - n += 2 + l + sovTrace(uint64(l)) - } - } return n } @@ -1523,27 +1331,6 @@ func (m *ScopeSpans) Size() (n int) { return n } -func (m *InstrumentationLibrarySpans) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.InstrumentationLibrary.Size() - n += 1 + l + sovTrace(uint64(l)) - if len(m.Spans) > 0 { - for _, e := range m.Spans { - l = e.Size() - n += 1 + l + sovTrace(uint64(l)) - } - } - l = len(m.SchemaUrl) - if l > 0 { - n += 1 + l + sovTrace(uint64(l)) - } - return n -} - func (m *Span) Size() (n int) { if m == nil { return 0 @@ -1890,40 +1677,6 @@ func (m *ResourceSpans) Unmarshal(dAtA []byte) error { } m.SchemaUrl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 1000: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InstrumentationLibrarySpans", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTrace - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTrace - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTrace - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.InstrumentationLibrarySpans = append(m.InstrumentationLibrarySpans, &InstrumentationLibrarySpans{}) - if err := m.InstrumentationLibrarySpans[len(m.InstrumentationLibrarySpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTrace(dAtA[iNdEx:]) @@ -2094,155 +1847,6 @@ func (m *ScopeSpans) Unmarshal(dAtA []byte) error { } return nil } -func (m *InstrumentationLibrarySpans) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTrace - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: InstrumentationLibrarySpans: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: InstrumentationLibrarySpans: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InstrumentationLibrary", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTrace - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTrace - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTrace - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.InstrumentationLibrary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTrace - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTrace - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTrace - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Spans = append(m.Spans, &Span{}) - if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SchemaUrl", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTrace - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthTrace - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthTrace - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SchemaUrl = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTrace(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTrace - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *Span) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/proto_patch.sed b/proto_patch.sed index d00e35af57c..f8a649c267c 100644 --- a/proto_patch.sed +++ b/proto_patch.sed @@ -37,9 +37,6 @@ s+repeated opentelemetry.proto.common.v1.StringKeyValue \([^]]*\);+repeated open s+opentelemetry.proto.resource.v1.Resource resource = \(.*\);+opentelemetry.proto.resource.v1.Resource resource = \1\ [ (gogoproto.nullable) = false ];+g -s+opentelemetry.proto.common.v1.InstrumentationLibrary instrumentation_library = \(.*\);+opentelemetry.proto.common.v1.InstrumentationLibrary instrumentation_library = \1\ - [ (gogoproto.nullable) = false ];+g - s+opentelemetry.proto.common.v1.InstrumentationScope scope = \(.*\);+opentelemetry.proto.common.v1.InstrumentationScope scope = \1\ [ (gogoproto.nullable) = false ];+g