From 1c0917052f79c16d037aff713757bf5ab03bcbd1 Mon Sep 17 00:00:00 2001 From: Bogdan Drutu Date: Sat, 9 Aug 2025 21:56:54 -0700 Subject: [PATCH] Generate Logs/Traces/Metrics and ExportResponse, removes hand written JSON encoding Signed-off-by: Bogdan Drutu --- .chloggen/generate-more.yaml | 25 ++++ internal/cmd/pdatagen/internal/base_slices.go | 27 +++-- internal/cmd/pdatagen/internal/base_struct.go | 19 ++- internal/cmd/pdatagen/internal/field.go | 8 +- .../cmd/pdatagen/internal/message_field.go | 28 +++-- .../cmd/pdatagen/internal/one_of_field.go | 4 +- .../cmd/pdatagen/internal/plog_package.go | 18 +++ .../cmd/pdatagen/internal/plogotlp_package.go | 14 +++ .../cmd/pdatagen/internal/pmetric_package.go | 18 +++ .../pdatagen/internal/pmetricotlp_package.go | 14 +++ .../cmd/pdatagen/internal/pprofile_package.go | 24 ++++ .../pdatagen/internal/pprofileotlp_package.go | 14 +++ .../cmd/pdatagen/internal/primitive_field.go | 4 +- .../internal/primitive_slice_structs.go | 4 + .../cmd/pdatagen/internal/ptrace_package.go | 18 +++ .../pdatagen/internal/ptraceotlp_package.go | 14 +++ internal/cmd/pdatagen/internal/slice_field.go | 12 +- .../internal/templates/message.go.tmpl | 6 +- .../templates/message_internal.go.tmpl | 2 +- .../internal/templates/message_test.go.tmpl | 2 +- .../pdatagen/internal/templates/slice.go.tmpl | 6 +- .../internal/templates/slice_internal.go.tmpl | 2 +- .../internal/templates/slice_test.go.tmpl | 2 +- internal/cmd/pdatagen/internal/typed_field.go | 2 +- ...erated_wrapper_exportlogsservicerequest.go | 97 +++++++++++++++ ...d_wrapper_exportlogsservicerequest_test.go | 71 +++++++++++ ...rated_wrapper_exportlogsserviceresponse.go | 69 +++++++++++ ..._wrapper_exportlogsserviceresponse_test.go | 71 +++++++++++ ...ted_wrapper_exportmetricsservicerequest.go | 97 +++++++++++++++ ...rapper_exportmetricsservicerequest_test.go | 71 +++++++++++ ...ed_wrapper_exportmetricsserviceresponse.go | 69 +++++++++++ ...apper_exportmetricsserviceresponse_test.go | 71 +++++++++++ ...ed_wrapper_exportprofilesservicerequest.go | 112 ++++++++++++++++++ ...apper_exportprofilesservicerequest_test.go | 71 +++++++++++ ...d_wrapper_exportprofilesserviceresponse.go | 69 +++++++++++ ...pper_exportprofilesserviceresponse_test.go | 71 +++++++++++ ...rated_wrapper_exporttraceservicerequest.go | 97 +++++++++++++++ ..._wrapper_exporttraceservicerequest_test.go | 71 +++++++++++ ...ated_wrapper_exporttraceserviceresponse.go | 69 +++++++++++ ...wrapper_exporttraceserviceresponse_test.go | 71 +++++++++++ pdata/internal/wrapper_logs.go | 17 --- pdata/internal/wrapper_metrics.go | 17 --- pdata/internal/wrapper_profiles.go | 17 --- pdata/internal/wrapper_traces.go | 17 --- pdata/plog/generated_logs.go | 67 +++++++++++ pdata/plog/generated_logs_test.go | 52 ++++++++ pdata/plog/json.go | 5 +- pdata/plog/logs.go | 61 +--------- pdata/plog/logs_test.go | 26 +--- .../plog/plogotlp/generated_exportresponse.go | 61 ++++++++++ .../plogotlp/generated_exportresponse_test.go | 54 +++++++++ pdata/plog/plogotlp/response.go | 40 +------ pdata/pmetric/generated_metrics.go | 67 +++++++++++ pdata/pmetric/generated_metrics_test.go | 52 ++++++++ pdata/pmetric/json.go | 5 +- pdata/pmetric/metrics.go | 55 --------- pdata/pmetric/metrics_test.go | 38 +++--- .../pmetricotlp/generated_exportresponse.go | 61 ++++++++++ .../generated_exportresponse_test.go | 60 ++++++++++ pdata/pmetric/pmetricotlp/response.go | 40 +------ pdata/pprofile/generated_profiles.go | 72 +++++++++++ pdata/pprofile/generated_profiles_test.go | 59 +++++++++ pdata/pprofile/json.go | 11 +- .../pprofileotlp/generated_exportresponse.go | 61 ++++++++++ .../generated_exportresponse_test.go | 60 ++++++++++ pdata/pprofile/pprofileotlp/response.go | 40 +------ pdata/pprofile/profiles.go | 72 +---------- pdata/pprofile/profiles_test.go | 13 +- pdata/ptrace/generated_traces.go | 67 +++++++++++ pdata/ptrace/generated_traces_test.go | 52 ++++++++ pdata/ptrace/json.go | 5 +- .../ptraceotlp/generated_exportresponse.go | 61 ++++++++++ .../generated_exportresponse_test.go | 54 +++++++++ pdata/ptrace/ptraceotlp/response.go | 40 +------ pdata/ptrace/traces.go | 61 +--------- pdata/ptrace/traces_test.go | 14 +-- 76 files changed, 2508 insertions(+), 580 deletions(-) create mode 100644 .chloggen/generate-more.yaml create mode 100644 pdata/internal/generated_wrapper_exportlogsservicerequest.go create mode 100644 pdata/internal/generated_wrapper_exportlogsservicerequest_test.go create mode 100644 pdata/internal/generated_wrapper_exportlogsserviceresponse.go create mode 100644 pdata/internal/generated_wrapper_exportlogsserviceresponse_test.go create mode 100644 pdata/internal/generated_wrapper_exportmetricsservicerequest.go create mode 100644 pdata/internal/generated_wrapper_exportmetricsservicerequest_test.go create mode 100644 pdata/internal/generated_wrapper_exportmetricsserviceresponse.go create mode 100644 pdata/internal/generated_wrapper_exportmetricsserviceresponse_test.go create mode 100644 pdata/internal/generated_wrapper_exportprofilesservicerequest.go create mode 100644 pdata/internal/generated_wrapper_exportprofilesservicerequest_test.go create mode 100644 pdata/internal/generated_wrapper_exportprofilesserviceresponse.go create mode 100644 pdata/internal/generated_wrapper_exportprofilesserviceresponse_test.go create mode 100644 pdata/internal/generated_wrapper_exporttraceservicerequest.go create mode 100644 pdata/internal/generated_wrapper_exporttraceservicerequest_test.go create mode 100644 pdata/internal/generated_wrapper_exporttraceserviceresponse.go create mode 100644 pdata/internal/generated_wrapper_exporttraceserviceresponse_test.go create mode 100644 pdata/plog/generated_logs.go create mode 100644 pdata/plog/generated_logs_test.go create mode 100644 pdata/plog/plogotlp/generated_exportresponse.go create mode 100644 pdata/plog/plogotlp/generated_exportresponse_test.go create mode 100644 pdata/pmetric/generated_metrics.go create mode 100644 pdata/pmetric/generated_metrics_test.go create mode 100644 pdata/pmetric/pmetricotlp/generated_exportresponse.go create mode 100644 pdata/pmetric/pmetricotlp/generated_exportresponse_test.go create mode 100644 pdata/pprofile/generated_profiles.go create mode 100644 pdata/pprofile/generated_profiles_test.go create mode 100644 pdata/pprofile/pprofileotlp/generated_exportresponse.go create mode 100644 pdata/pprofile/pprofileotlp/generated_exportresponse_test.go create mode 100644 pdata/ptrace/generated_traces.go create mode 100644 pdata/ptrace/generated_traces_test.go create mode 100644 pdata/ptrace/ptraceotlp/generated_exportresponse.go create mode 100644 pdata/ptrace/ptraceotlp/generated_exportresponse_test.go diff --git a/.chloggen/generate-more.yaml b/.chloggen/generate-more.yaml new file mode 100644 index 00000000000..25c7a4f46b5 --- /dev/null +++ b/.chloggen/generate-more.yaml @@ -0,0 +1,25 @@ +# Use this changelog template to create an entry for release notes. + +# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix' +change_type: enhancement + +# The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver) +component: pdata + +# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`). +note: Generate Logs/Traces/Metrics/Profiles and p[log|trace|metric|profile]ExportResponse with pdatagen. + +# One or more tracking issues or pull requests related to the change +issues: [13597] + +# (Optional) One or more lines of additional information to render under the primary note. +# These lines will be padded with 2 spaces and then inserted directly into the document. +# Use pipe (|) for multiline entries. +subtext: This change brings consistency on how these structs are written and remove JSON marshaling/unmarshaling hand written logic. + +# Optional: The change log or logs in which this entry should be included. +# e.g. '[user]' or '[user, api]' +# Include 'user' if the change is relevant to end users. +# Include 'api' if there is a change to a library API. +# Default: '[user]' +change_logs: [api, user] diff --git a/internal/cmd/pdatagen/internal/base_slices.go b/internal/cmd/pdatagen/internal/base_slices.go index 020c676ffc2..5360b2e896b 100644 --- a/internal/cmd/pdatagen/internal/base_slices.go +++ b/internal/cmd/pdatagen/internal/base_slices.go @@ -6,6 +6,7 @@ package internal // import "go.opentelemetry.io/collector/internal/cmd/pdatagen/ type baseSlice interface { getName() string getOriginName() string + getHasWrapper() bool getElementProtoType() ProtoType getElementOriginName() string getPackageName() string @@ -43,11 +44,12 @@ func (ss *sliceOfPtrs) generateInternalTests(packageInfo *PackageInfo) []byte { } func (ss *sliceOfPtrs) templateFields(packageInfo *PackageInfo) map[string]any { - orig := origAccessor(ss.packageName) - state := stateAccessor(ss.packageName) + hasWrapper := usedByOtherDataTypes(ss.packageName) + orig := origAccessor(hasWrapper) + state := stateAccessor(hasWrapper) return map[string]any{ "type": "sliceOfPtrs", - "isCommon": usedByOtherDataTypes(ss.packageName), + "hasWrapper": usedByOtherDataTypes(ss.packageName), "structName": ss.structName, "elementName": ss.element.getName(), "elementOriginFullName": ss.element.originFullName, @@ -56,8 +58,8 @@ func (ss *sliceOfPtrs) templateFields(packageInfo *PackageInfo) map[string]any { "originElementPtr": "", "emptyOriginElement": "&" + ss.element.originFullName + "{}", "newElement": "new" + ss.element.getName() + "((*es." + orig + ")[i], es." + state + ")", - "origAccessor": orig, - "stateAccessor": state, + "origAccessor": origAccessor(hasWrapper), + "stateAccessor": stateAccessor(hasWrapper), "packageName": packageInfo.name, "imports": packageInfo.imports, "testImports": packageInfo.testImports, @@ -72,6 +74,10 @@ func (ss *sliceOfPtrs) getElementProtoType() ProtoType { return ProtoTypeMessage } +func (ss *sliceOfPtrs) getHasWrapper() bool { + return usedByOtherDataTypes(ss.packageName) +} + func (ss *sliceOfPtrs) getElementOriginName() string { return ss.element.getOriginName() } @@ -110,11 +116,12 @@ func (ss *sliceOfValues) generateInternalTests(packageInfo *PackageInfo) []byte } func (ss *sliceOfValues) templateFields(packageInfo *PackageInfo) map[string]any { - orig := origAccessor(ss.packageName) - state := stateAccessor(ss.packageName) + hasWrapper := usedByOtherDataTypes(ss.packageName) + orig := origAccessor(hasWrapper) + state := stateAccessor(hasWrapper) return map[string]any{ "type": "sliceOfValues", - "isCommon": usedByOtherDataTypes(ss.packageName), + "hasWrapper": usedByOtherDataTypes(ss.packageName), "structName": ss.getName(), "elementName": ss.element.getName(), "elementOriginFullName": ss.element.originFullName, @@ -139,6 +146,10 @@ func (ss *sliceOfValues) getElementProtoType() ProtoType { return ProtoTypeMessage } +func (ss *sliceOfValues) getHasWrapper() bool { + return usedByOtherDataTypes(ss.packageName) +} + func (ss *sliceOfValues) getElementOriginName() string { return ss.element.getOriginName() } diff --git a/internal/cmd/pdatagen/internal/base_struct.go b/internal/cmd/pdatagen/internal/base_struct.go index 40df0a62131..b602f6e76e7 100644 --- a/internal/cmd/pdatagen/internal/base_struct.go +++ b/internal/cmd/pdatagen/internal/base_struct.go @@ -9,6 +9,7 @@ import ( type baseStruct interface { getName() string getOriginName() string + getHasWrapper() bool generate(packageInfo *PackageInfo) []byte generateTests(packageInfo *PackageInfo) []byte generateInternal(packageInfo *PackageInfo) []byte @@ -23,6 +24,7 @@ type messageStruct struct { description string originFullName string fields []Field + hasWrapper bool } func (ms *messageStruct) getName() string { @@ -46,6 +48,10 @@ func (ms *messageStruct) generateInternalTests(packageInfo *PackageInfo) []byte } func (ms *messageStruct) templateFields(packageInfo *PackageInfo) map[string]any { + hasWrapper := ms.hasWrapper + if !hasWrapper { + hasWrapper = usedByOtherDataTypes(ms.packageName) + } return map[string]any{ "messageStruct": ms, "fields": ms.fields, @@ -53,15 +59,22 @@ func (ms *messageStruct) templateFields(packageInfo *PackageInfo) map[string]any "originFullName": ms.originFullName, "originName": ms.getOriginName(), "description": ms.description, - "isCommon": usedByOtherDataTypes(ms.packageName), - "origAccessor": origAccessor(ms.packageName), - "stateAccessor": stateAccessor(ms.packageName), + "hasWrapper": hasWrapper, + "origAccessor": origAccessor(hasWrapper), + "stateAccessor": stateAccessor(hasWrapper), "packageName": packageInfo.name, "imports": packageInfo.imports, "testImports": packageInfo.testImports, } } +func (ms *messageStruct) getHasWrapper() bool { + if ms.hasWrapper { + return true + } + return usedByOtherDataTypes(ms.packageName) +} + func (ms *messageStruct) getOriginName() string { _, after, _ := strings.Cut(ms.originFullName, ".") return after diff --git a/internal/cmd/pdatagen/internal/field.go b/internal/cmd/pdatagen/internal/field.go index 532fd3e7434..654821cd641 100644 --- a/internal/cmd/pdatagen/internal/field.go +++ b/internal/cmd/pdatagen/internal/field.go @@ -21,15 +21,15 @@ type Field interface { GenerateMarshalProto(ms *messageStruct) string } -func origAccessor(packageName string) string { - if usedByOtherDataTypes(packageName) { +func origAccessor(hasWrapper bool) string { + if hasWrapper { return "getOrig()" } return "orig" } -func stateAccessor(packageName string) string { - if usedByOtherDataTypes(packageName) { +func stateAccessor(hasWrapper bool) string { + if hasWrapper { return "getState()" } return "state" diff --git a/internal/cmd/pdatagen/internal/message_field.go b/internal/cmd/pdatagen/internal/message_field.go index 076bf61080b..c088b301c1f 100644 --- a/internal/cmd/pdatagen/internal/message_field.go +++ b/internal/cmd/pdatagen/internal/message_field.go @@ -10,7 +10,7 @@ import ( const messageAccessorsTemplate = `// {{ .fieldName }} returns the {{ .lowerFieldName }} associated with this {{ .structName }}. func (ms {{ .structName }}) {{ .fieldName }}() {{ .packageName }}{{ .returnType }} { - {{- if .isCommon }} + {{- if .messageHasWrapper }} return {{ .packageName }}{{ .returnType }}(internal.New{{ .returnType }}(&ms.{{ .origAccessor }}.{{ .fieldOriginFullName }}, ms.{{ .stateAccessor }})) {{- else }} return new{{ .returnType }}(&ms.{{ .origAccessor }}.{{ .fieldOriginFullName }}, ms.{{ .stateAccessor }}) @@ -21,7 +21,7 @@ const messageAccessorsTestTemplate = `func Test{{ .structName }}_{{ .fieldName } ms := New{{ .structName }}() assert.Equal(t, {{ .packageName }}New{{ .returnType }}{{- if eq .returnType "Value" }}Empty{{- end }}(), ms.{{ .fieldName }}()) internal.FillOrigTest{{ .fieldOriginName }}(&ms.{{ .origAccessor }}.{{ .fieldOriginFullName }}) - {{- if .isCommon }} + {{- if .messageHasWrapper }} assert.Equal(t, {{ .packageName }}{{ .returnType }}(internal.GenerateTest{{ .returnType }}()), ms.{{ .fieldName }}()) {{- else }} assert.Equal(t, generateTest{{ .returnType }}(), ms.{{ .fieldName }}()) @@ -41,9 +41,10 @@ const messageUnmarshalJSONTemplate = `case "{{ lowerFirst .fieldOriginFullName } UnmarshalJSONOrig{{ .fieldOriginName }}(&orig.{{ .fieldOriginFullName }}, iter)` type MessageField struct { - fieldName string - protoID uint32 - returnMessage *messageStruct + fieldName string + fieldOriginFullName string + protoID uint32 + returnMessage *messageStruct } func (mf *MessageField) GenerateAccessors(ms *messageStruct) string { @@ -92,17 +93,17 @@ func (mf *MessageField) toProtoField() *ProtoField { return &ProtoField{ Type: pt, ID: mf.protoID, - Name: mf.fieldName, + Name: mf.getFieldOriginFullName(), MessageName: mf.returnMessage.getOriginName(), } } func (mf *MessageField) templateFields(ms *messageStruct) map[string]any { return map[string]any{ - "isCommon": usedByOtherDataTypes(mf.returnMessage.packageName), + "messageHasWrapper": usedByOtherDataTypes(mf.returnMessage.packageName), "structName": ms.getName(), "fieldName": mf.fieldName, - "fieldOriginFullName": mf.fieldName, + "fieldOriginFullName": mf.getFieldOriginFullName(), "fieldOriginName": mf.returnMessage.getOriginName(), "lowerFieldName": strings.ToLower(mf.fieldName), "returnType": mf.returnMessage.getName(), @@ -112,9 +113,16 @@ func (mf *MessageField) templateFields(ms *messageStruct) map[string]any { } return "" }(), - "origAccessor": origAccessor(ms.packageName), - "stateAccessor": stateAccessor(ms.packageName), + "origAccessor": origAccessor(ms.getHasWrapper()), + "stateAccessor": stateAccessor(ms.getHasWrapper()), } } +func (mf *MessageField) getFieldOriginFullName() string { + if mf.fieldOriginFullName != "" { + return mf.fieldOriginFullName + } + return mf.fieldName +} + var _ Field = (*MessageField)(nil) diff --git a/internal/cmd/pdatagen/internal/one_of_field.go b/internal/cmd/pdatagen/internal/one_of_field.go index d01193d3f65..989992fbeea 100644 --- a/internal/cmd/pdatagen/internal/one_of_field.go +++ b/internal/cmd/pdatagen/internal/one_of_field.go @@ -129,8 +129,8 @@ func (of *OneOfField) templateFields(ms *messageStruct) map[string]any { "typeName": of.typeName, "originFieldName": of.originFieldName, "lowerOriginFieldName": strings.ToLower(of.originFieldName), - "origAccessor": origAccessor(ms.packageName), - "stateAccessor": stateAccessor(ms.packageName), + "origAccessor": origAccessor(ms.getHasWrapper()), + "stateAccessor": stateAccessor(ms.getHasWrapper()), "values": of.values, "originTypePrefix": ms.originFullName + "_", } diff --git a/internal/cmd/pdatagen/internal/plog_package.go b/internal/cmd/pdatagen/internal/plog_package.go index 21e44f4c33a..64ba2047408 100644 --- a/internal/cmd/pdatagen/internal/plog_package.go +++ b/internal/cmd/pdatagen/internal/plog_package.go @@ -17,6 +17,7 @@ var plog = &Package{ `"go.opentelemetry.io/collector/pdata/internal/data"`, `"go.opentelemetry.io/collector/pdata/internal/json"`, `"go.opentelemetry.io/collector/pdata/internal/proto"`, + `otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1"`, `otlplogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/logs/v1"`, `"go.opentelemetry.io/collector/pdata/pcommon"`, }, @@ -30,11 +31,13 @@ var plog = &Package{ `"go.opentelemetry.io/collector/pdata/internal"`, `"go.opentelemetry.io/collector/pdata/internal/data"`, `"go.opentelemetry.io/collector/pdata/internal/json"`, + `otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1"`, `otlplogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/logs/v1"`, `"go.opentelemetry.io/collector/pdata/pcommon"`, }, }, structs: []baseStruct{ + logs, resourceLogsSlice, resourceLogs, scopeLogsSlice, @@ -44,6 +47,21 @@ var plog = &Package{ }, } +var logs = &messageStruct{ + structName: "Logs", + description: "// Logs is the top-level struct that is propagated through the logs pipeline.\n// Use NewLogs to create new instance, zero-initialized instance is not valid for use.", + originFullName: "otlpcollectorlog.ExportLogsServiceRequest", + fields: []Field{ + &SliceField{ + fieldName: "ResourceLogs", + protoID: 1, + protoType: ProtoTypeMessage, + returnSlice: resourceLogsSlice, + }, + }, + hasWrapper: true, +} + var resourceLogsSlice = &sliceOfPtrs{ structName: "ResourceLogsSlice", element: resourceLogs, diff --git a/internal/cmd/pdatagen/internal/plogotlp_package.go b/internal/cmd/pdatagen/internal/plogotlp_package.go index 6879cf4a182..d3a94ca280e 100644 --- a/internal/cmd/pdatagen/internal/plogotlp_package.go +++ b/internal/cmd/pdatagen/internal/plogotlp_package.go @@ -27,10 +27,24 @@ var plogotlp = &Package{ }, }, structs: []baseStruct{ + exportLogsResponse, exportLogsPartialSuccess, }, } +var exportLogsResponse = &messageStruct{ + structName: "ExportResponse", + description: "// ExportResponse represents the response for gRPC/HTTP client/server.", + originFullName: "otlpcollectorlog.ExportLogsServiceResponse", + fields: []Field{ + &MessageField{ + fieldName: "PartialSuccess", + protoID: 1, + returnMessage: exportLogsPartialSuccess, + }, + }, +} + var exportLogsPartialSuccess = &messageStruct{ structName: "ExportPartialSuccess", description: "// ExportPartialSuccess represents the details of a partially successful export request.", diff --git a/internal/cmd/pdatagen/internal/pmetric_package.go b/internal/cmd/pdatagen/internal/pmetric_package.go index 075cae88e1d..17e819045fe 100644 --- a/internal/cmd/pdatagen/internal/pmetric_package.go +++ b/internal/cmd/pdatagen/internal/pmetric_package.go @@ -17,6 +17,7 @@ var pmetric = &Package{ `"go.opentelemetry.io/collector/pdata/internal/data"`, `"go.opentelemetry.io/collector/pdata/internal/json"`, `"go.opentelemetry.io/collector/pdata/internal/proto"`, + `otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1"`, `otlpmetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/metrics/v1"`, `"go.opentelemetry.io/collector/pdata/pcommon"`, }, @@ -30,11 +31,13 @@ var pmetric = &Package{ `"go.opentelemetry.io/collector/pdata/internal"`, `"go.opentelemetry.io/collector/pdata/internal/data"`, `"go.opentelemetry.io/collector/pdata/internal/json"`, + `otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1"`, `otlpmetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/metrics/v1"`, `"go.opentelemetry.io/collector/pdata/pcommon"`, }, }, structs: []baseStruct{ + metrics, resourceMetricsSlice, resourceMetrics, scopeMetricsSlice, @@ -62,6 +65,21 @@ var pmetric = &Package{ }, } +var metrics = &messageStruct{ + structName: "Metrics", + description: "// Metrics is the top-level struct that is propagated through the metrics pipeline.\n// Use NewMetrics to create new instance, zero-initialized instance is not valid for use.", + originFullName: "otlpcollectormetrics.ExportMetricsServiceRequest", + fields: []Field{ + &SliceField{ + fieldName: "ResourceMetrics", + protoID: 1, + protoType: ProtoTypeMessage, + returnSlice: resourceMetricsSlice, + }, + }, + hasWrapper: true, +} + var resourceMetricsSlice = &sliceOfPtrs{ structName: "ResourceMetricsSlice", element: resourceMetrics, diff --git a/internal/cmd/pdatagen/internal/pmetricotlp_package.go b/internal/cmd/pdatagen/internal/pmetricotlp_package.go index 390428d70e4..3589db10902 100644 --- a/internal/cmd/pdatagen/internal/pmetricotlp_package.go +++ b/internal/cmd/pdatagen/internal/pmetricotlp_package.go @@ -28,10 +28,24 @@ var pmetricotlp = &Package{ }, }, structs: []baseStruct{ + exportMetricsResponse, exportMetricsPartialSuccess, }, } +var exportMetricsResponse = &messageStruct{ + structName: "ExportResponse", + description: "// ExportResponse represents the response for gRPC/HTTP client/server.", + originFullName: "otlpcollectormetrics.ExportMetricsServiceResponse", + fields: []Field{ + &MessageField{ + fieldName: "PartialSuccess", + protoID: 1, + returnMessage: exportMetricsPartialSuccess, + }, + }, +} + var exportMetricsPartialSuccess = &messageStruct{ structName: "ExportPartialSuccess", description: "// ExportPartialSuccess represents the details of a partially successful export request.", diff --git a/internal/cmd/pdatagen/internal/pprofile_package.go b/internal/cmd/pdatagen/internal/pprofile_package.go index 37815ff8a1b..b170b5ea9ea 100644 --- a/internal/cmd/pdatagen/internal/pprofile_package.go +++ b/internal/cmd/pdatagen/internal/pprofile_package.go @@ -17,6 +17,7 @@ var pprofile = &Package{ `"go.opentelemetry.io/collector/pdata/internal/data"`, `"go.opentelemetry.io/collector/pdata/internal/json"`, `"go.opentelemetry.io/collector/pdata/internal/proto"`, + `otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development"`, `otlpprofiles "go.opentelemetry.io/collector/pdata/internal/data/protogen/profiles/v1development"`, `"go.opentelemetry.io/collector/pdata/pcommon"`, }, @@ -29,11 +30,13 @@ var pprofile = &Package{ ``, `"go.opentelemetry.io/collector/pdata/internal"`, `"go.opentelemetry.io/collector/pdata/internal/json"`, + `otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development"`, `otlpprofiles "go.opentelemetry.io/collector/pdata/internal/data/protogen/profiles/v1development"`, `"go.opentelemetry.io/collector/pdata/pcommon"`, }, }, structs: []baseStruct{ + profiles, resourceProfilesSlice, resourceProfiles, profilesDictionary, @@ -62,6 +65,27 @@ var pprofile = &Package{ }, } +var profiles = &messageStruct{ + structName: "Profiles", + description: "// Profiles is the top-level struct that is propagated through the profiles pipeline.\n// Use NewProfiles to create new instance, zero-initialized instance is not valid for use.", + originFullName: "otlpcollectorprofile.ExportProfilesServiceRequest", + fields: []Field{ + &SliceField{ + fieldName: "ResourceProfiles", + protoID: 1, + protoType: ProtoTypeMessage, + returnSlice: resourceProfilesSlice, + }, + &MessageField{ + fieldName: "ProfilesDictionary", + fieldOriginFullName: "Dictionary", + protoID: 2, + returnMessage: profilesDictionary, + }, + }, + hasWrapper: true, +} + var resourceProfilesSlice = &sliceOfPtrs{ structName: "ResourceProfilesSlice", element: resourceProfiles, diff --git a/internal/cmd/pdatagen/internal/pprofileotlp_package.go b/internal/cmd/pdatagen/internal/pprofileotlp_package.go index e20379e9c4c..1c0b440ffce 100644 --- a/internal/cmd/pdatagen/internal/pprofileotlp_package.go +++ b/internal/cmd/pdatagen/internal/pprofileotlp_package.go @@ -27,10 +27,24 @@ var pprofileotlp = &Package{ }, }, structs: []baseStruct{ + exportProfilesResponse, exportProfilesPartialSuccess, }, } +var exportProfilesResponse = &messageStruct{ + structName: "ExportResponse", + description: "// ExportResponse represents the response for gRPC/HTTP client/server.", + originFullName: "otlpcollectorprofile.ExportProfilesServiceResponse", + fields: []Field{ + &MessageField{ + fieldName: "PartialSuccess", + protoID: 1, + returnMessage: exportProfilesPartialSuccess, + }, + }, +} + var exportProfilesPartialSuccess = &messageStruct{ structName: "ExportPartialSuccess", description: "// ExportPartialSuccess represents the details of a partially successful export request.", diff --git a/internal/cmd/pdatagen/internal/primitive_field.go b/internal/cmd/pdatagen/internal/primitive_field.go index a3ee66ff3ff..0f9130bfe68 100644 --- a/internal/cmd/pdatagen/internal/primitive_field.go +++ b/internal/cmd/pdatagen/internal/primitive_field.go @@ -117,8 +117,8 @@ func (pf *PrimitiveField) templateFields(ms *messageStruct) map[string]any { "lowerFieldName": strings.ToLower(pf.fieldName), "testValue": pf.protoType.testValue(pf.fieldName), "returnType": pf.protoType.goType(""), - "origAccessor": origAccessor(ms.packageName), - "stateAccessor": stateAccessor(ms.packageName), + "origAccessor": origAccessor(ms.getHasWrapper()), + "stateAccessor": stateAccessor(ms.getHasWrapper()), "originStructName": ms.originFullName, "originFieldName": pf.fieldName, } diff --git a/internal/cmd/pdatagen/internal/primitive_slice_structs.go b/internal/cmd/pdatagen/internal/primitive_slice_structs.go index 7fdbd782b9f..b0b5fc8a9ae 100644 --- a/internal/cmd/pdatagen/internal/primitive_slice_structs.go +++ b/internal/cmd/pdatagen/internal/primitive_slice_structs.go @@ -52,6 +52,10 @@ func (iss *primitiveSliceStruct) getElementProtoType() ProtoType { return ProtoTypeInt64 } +func (iss *primitiveSliceStruct) getHasWrapper() bool { + return usedByOtherDataTypes(iss.packageName) +} + func (iss *primitiveSliceStruct) getElementOriginName() string { return upperFirst(iss.itemType) } diff --git a/internal/cmd/pdatagen/internal/ptrace_package.go b/internal/cmd/pdatagen/internal/ptrace_package.go index 86ab76643f1..b7a8da5ea9c 100644 --- a/internal/cmd/pdatagen/internal/ptrace_package.go +++ b/internal/cmd/pdatagen/internal/ptrace_package.go @@ -17,6 +17,7 @@ var ptrace = &Package{ `"go.opentelemetry.io/collector/pdata/internal/data"`, `"go.opentelemetry.io/collector/pdata/internal/json"`, `"go.opentelemetry.io/collector/pdata/internal/proto"`, + `otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1"`, `otlptrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/trace/v1"`, `"go.opentelemetry.io/collector/pdata/pcommon"`, }, @@ -30,11 +31,13 @@ var ptrace = &Package{ `"go.opentelemetry.io/collector/pdata/internal"`, `"go.opentelemetry.io/collector/pdata/internal/data"`, `"go.opentelemetry.io/collector/pdata/internal/json"`, + `otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1"`, `otlptrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/trace/v1"`, `"go.opentelemetry.io/collector/pdata/pcommon"`, }, }, structs: []baseStruct{ + traces, resourceSpansSlice, resourceSpans, scopeSpansSlice, @@ -49,6 +52,21 @@ var ptrace = &Package{ }, } +var traces = &messageStruct{ + structName: "Traces", + description: "// Traces is the top-level struct that is propagated through the traces pipeline.\n// Use NewTraces to create new instance, zero-initialized instance is not valid for use.", + originFullName: "otlpcollectortrace.ExportTraceServiceRequest", + fields: []Field{ + &SliceField{ + fieldName: "ResourceSpans", + protoID: 1, + protoType: ProtoTypeMessage, + returnSlice: resourceSpansSlice, + }, + }, + hasWrapper: true, +} + var resourceSpansSlice = &sliceOfPtrs{ structName: "ResourceSpansSlice", element: resourceSpans, diff --git a/internal/cmd/pdatagen/internal/ptraceotlp_package.go b/internal/cmd/pdatagen/internal/ptraceotlp_package.go index 4bb5d90c016..9a4afbb1c94 100644 --- a/internal/cmd/pdatagen/internal/ptraceotlp_package.go +++ b/internal/cmd/pdatagen/internal/ptraceotlp_package.go @@ -28,10 +28,24 @@ var ptraceotlp = &Package{ }, }, structs: []baseStruct{ + exportTraceResponse, exportTracePartialSuccess, }, } +var exportTraceResponse = &messageStruct{ + structName: "ExportResponse", + description: "// ExportResponse represents the response for gRPC/HTTP client/server.", + originFullName: "otlpcollectortrace.ExportTraceServiceResponse", + fields: []Field{ + &MessageField{ + fieldName: "PartialSuccess", + protoID: 1, + returnMessage: exportTracePartialSuccess, + }, + }, +} + var exportTracePartialSuccess = &messageStruct{ structName: "ExportPartialSuccess", description: "// ExportPartialSuccess represents the details of a partially successful export request.", diff --git a/internal/cmd/pdatagen/internal/slice_field.go b/internal/cmd/pdatagen/internal/slice_field.go index 9a69cd3afe7..ca5693e08d1 100644 --- a/internal/cmd/pdatagen/internal/slice_field.go +++ b/internal/cmd/pdatagen/internal/slice_field.go @@ -9,7 +9,7 @@ import ( const sliceAccessorTemplate = `// {{ .fieldName }} returns the {{ .fieldName }} associated with this {{ .structName }}. func (ms {{ .structName }}) {{ .fieldName }}() {{ .packageName }}{{ .returnType }} { - {{- if .isCommon }} + {{- if .elementHasWrapper }} return {{ .packageName }}{{ .returnType }}(internal.New{{ .returnType }}(&ms.{{ .origAccessor }}.{{ .originFieldName }}, ms.{{ .stateAccessor }})) {{- else }} return new{{ .returnType }}(&ms.{{ .origAccessor }}.{{ .originFieldName }}, ms.{{ .stateAccessor }}) @@ -20,7 +20,7 @@ const sliceAccessorsTestTemplate = `func Test{{ .structName }}_{{ .fieldName }}( ms := New{{ .structName }}() assert.Equal(t, {{ .packageName }}New{{ .returnType }}(), ms.{{ .fieldName }}()) ms.{{ .origAccessor }}.{{ .originFieldName }} = internal.GenerateOrigTest{{ .elementOriginName }}Slice() - {{- if .isCommon }} + {{- if .elementHasWrapper }} assert.Equal(t, {{ .packageName }}{{ .returnType }}(internal.GenerateTest{{ .returnType }}()), ms.{{ .fieldName }}()) {{- else }} assert.Equal(t, generateTest{{ .returnType }}(), ms.{{ .fieldName }}()) @@ -115,10 +115,10 @@ func (sf *SliceField) templateFields(ms *messageStruct) map[string]any { } return "" }(), - "returnType": sf.returnSlice.getName(), - "origAccessor": origAccessor(ms.packageName), - "stateAccessor": stateAccessor(ms.packageName), - "isCommon": usedByOtherDataTypes(sf.returnSlice.getPackageName()), + "returnType": sf.returnSlice.getName(), + "origAccessor": origAccessor(ms.getHasWrapper()), + "stateAccessor": stateAccessor(ms.getHasWrapper()), + "elementHasWrapper": sf.returnSlice.getHasWrapper(), } } diff --git a/internal/cmd/pdatagen/internal/templates/message.go.tmpl b/internal/cmd/pdatagen/internal/templates/message.go.tmpl index aa67000280b..b78e0dc45eb 100644 --- a/internal/cmd/pdatagen/internal/templates/message.go.tmpl +++ b/internal/cmd/pdatagen/internal/templates/message.go.tmpl @@ -19,7 +19,7 @@ import ( // // Must use New{{ .structName }} function to create new instances. // Important: zero-initialized instance is not valid for use. -{{- if .isCommon }} +{{- if .hasWrapper }} type {{ .structName }} internal.{{ .structName }} {{- else }} type {{ .structName }} struct { @@ -29,7 +29,7 @@ type {{ .structName }} struct { {{- end }} func new{{ .structName }}(orig *{{ .originFullName }}, state *internal.State) {{ .structName }} { - {{- if .isCommon }} + {{- if .hasWrapper }} return {{ .structName }}(internal.New{{ .structName }}(orig, state)) {{- else }} return {{ .structName }}{orig: orig, state: state} @@ -68,7 +68,7 @@ func (ms {{ .structName }}) CopyTo(dest {{ .structName }}) { internal.CopyOrig{{ .originName }}(dest.{{ .origAccessor }}, ms.{{ .origAccessor }}) } -{{ if .isCommon -}} +{{ if .hasWrapper -}} func (ms {{ .structName }}) getOrig() *{{ .originFullName }} { return internal.GetOrig{{ .structName }}(internal.{{ .structName }}(ms)) } diff --git a/internal/cmd/pdatagen/internal/templates/message_internal.go.tmpl b/internal/cmd/pdatagen/internal/templates/message_internal.go.tmpl index 69291a7ec49..33dc80ed361 100644 --- a/internal/cmd/pdatagen/internal/templates/message_internal.go.tmpl +++ b/internal/cmd/pdatagen/internal/templates/message_internal.go.tmpl @@ -11,7 +11,7 @@ import ( {{ $element }} {{ end }} ) -{{ if .isCommon }} +{{ if .hasWrapper }} type {{ .structName }} struct { orig *{{ .originFullName }} diff --git a/internal/cmd/pdatagen/internal/templates/message_test.go.tmpl b/internal/cmd/pdatagen/internal/templates/message_test.go.tmpl index 72d61f472d4..1126376a34b 100644 --- a/internal/cmd/pdatagen/internal/templates/message_test.go.tmpl +++ b/internal/cmd/pdatagen/internal/templates/message_test.go.tmpl @@ -42,7 +42,7 @@ func Test{{ .structName }}_CopyTo(t *testing.T) { {{ end }} func generateTest{{ .structName }}() {{ .structName }} { - {{- if .isCommon }} + {{- if .hasWrapper }} return {{ .structName }}(internal.GenerateTest{{ .structName }}()) {{- else }} ms := New{{ .structName }}() diff --git a/internal/cmd/pdatagen/internal/templates/slice.go.tmpl b/internal/cmd/pdatagen/internal/templates/slice.go.tmpl index ee7fdde6d6e..4d407ba15fa 100644 --- a/internal/cmd/pdatagen/internal/templates/slice.go.tmpl +++ b/internal/cmd/pdatagen/internal/templates/slice.go.tmpl @@ -19,7 +19,7 @@ import ( // // Must use New{{ .structName }} function to create new instances. // Important: zero-initialized instance is not valid for use. -{{- if .isCommon }} +{{- if .hasWrapper }} type {{ .structName }} internal.{{ .structName }} {{- else }} type {{ .structName }} struct { @@ -29,7 +29,7 @@ type {{ .structName }} struct { {{- end }} func new{{ .structName }}(orig *[]{{ .originElementType }}, state *internal.State) {{ .structName }} { - {{- if .isCommon }} + {{- if .hasWrapper }} return {{ .structName }}(internal.New{{ .structName }}(orig, state)) {{- else }} return {{ .structName }}{orig: orig, state: state} @@ -173,7 +173,7 @@ func (es {{ .structName }}) Sort(less func(a, b {{ .elementName }}) bool) { } {{- end }} -{{ if .isCommon -}} +{{ if .hasWrapper -}} func (ms {{ .structName }}) getOrig() *[]{{ .originElementType }} { return internal.GetOrig{{ .structName }}(internal.{{ .structName }}(ms)) } diff --git a/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl b/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl index c53eb9289db..a501c4f39f7 100644 --- a/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl +++ b/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl @@ -11,7 +11,7 @@ import ( {{ $element }} {{ end }} ) -{{ if .isCommon }} +{{ if .hasWrapper }} type {{ .structName }} struct { orig *[]{{ .originElementType }} diff --git a/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl b/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl index 1750802fdfc..aa09bc08996 100644 --- a/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl +++ b/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl @@ -24,7 +24,7 @@ func Test{{ .structName }}(t *testing.T) { {{- else }} emptyVal := New{{ .elementName }}() {{- end }} - {{- if .isCommon }} + {{- if .hasWrapper }} testVal := {{ .elementName }}(internal.GenerateTest{{ .elementName }}()) {{- else }} testVal := generateTest{{ .elementName }}() diff --git a/internal/cmd/pdatagen/internal/typed_field.go b/internal/cmd/pdatagen/internal/typed_field.go index e1c8aefc3ca..c3e77f6e893 100644 --- a/internal/cmd/pdatagen/internal/typed_field.go +++ b/internal/cmd/pdatagen/internal/typed_field.go @@ -127,7 +127,7 @@ func (ptf *TypedField) templateFields(ms *messageStruct) map[string]any { } return "" }(), - "isCommon": usedByOtherDataTypes(ptf.returnType.packageName), + "hasWrapper": usedByOtherDataTypes(ptf.returnType.packageName), "returnType": ptf.returnType.structName, "fieldName": ptf.fieldName, "lowerFieldName": strings.ToLower(ptf.fieldName), diff --git a/pdata/internal/generated_wrapper_exportlogsservicerequest.go b/pdata/internal/generated_wrapper_exportlogsservicerequest.go new file mode 100644 index 00000000000..befb6347a6b --- /dev/null +++ b/pdata/internal/generated_wrapper_exportlogsservicerequest.go @@ -0,0 +1,97 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" + "go.opentelemetry.io/collector/pdata/internal/json" + "go.opentelemetry.io/collector/pdata/internal/proto" +) + +type Logs struct { + orig *otlpcollectorlog.ExportLogsServiceRequest + state *State +} + +func GetOrigLogs(ms Logs) *otlpcollectorlog.ExportLogsServiceRequest { + return ms.orig +} + +func GetLogsState(ms Logs) *State { + return ms.state +} + +func NewLogs(orig *otlpcollectorlog.ExportLogsServiceRequest, state *State) Logs { + return Logs{orig: orig, state: state} +} + +func GenerateTestLogs() Logs { + orig := otlpcollectorlog.ExportLogsServiceRequest{} + FillOrigTestExportLogsServiceRequest(&orig) + state := StateMutable + return NewLogs(&orig, &state) +} + +func CopyOrigExportLogsServiceRequest(dest, src *otlpcollectorlog.ExportLogsServiceRequest) { + dest.ResourceLogs = CopyOrigResourceLogsSlice(dest.ResourceLogs, src.ResourceLogs) +} + +func FillOrigTestExportLogsServiceRequest(orig *otlpcollectorlog.ExportLogsServiceRequest) { + orig.ResourceLogs = GenerateOrigTestResourceLogsSlice() +} + +// MarshalJSONOrig marshals all properties from the current struct to the destination stream. +func MarshalJSONOrigExportLogsServiceRequest(orig *otlpcollectorlog.ExportLogsServiceRequest, dest *json.Stream) { + dest.WriteObjectStart() + if len(orig.ResourceLogs) > 0 { + dest.WriteObjectField("resourceLogs") + MarshalJSONOrigResourceLogsSlice(orig.ResourceLogs, dest) + } + dest.WriteObjectEnd() +} + +// UnmarshalJSONOrigLogs unmarshals all properties from the current struct from the source iterator. +func UnmarshalJSONOrigExportLogsServiceRequest(orig *otlpcollectorlog.ExportLogsServiceRequest, iter *json.Iterator) { + iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { + switch f { + case "resourceLogs", "resource_logs": + orig.ResourceLogs = UnmarshalJSONOrigResourceLogsSlice(iter) + default: + iter.Skip() + } + return true + }) +} + +func SizeProtoOrigExportLogsServiceRequest(orig *otlpcollectorlog.ExportLogsServiceRequest) int { + var n int + var l int + _ = l + for i := range orig.ResourceLogs { + l = SizeProtoOrigResourceLogs(orig.ResourceLogs[i]) + n += 1 + proto.Sov(uint64(l)) + l + } + return n +} + +func MarshalProtoOrigExportLogsServiceRequest(orig *otlpcollectorlog.ExportLogsServiceRequest, buf []byte) int { + pos := len(buf) + var l int + _ = l + for i := range orig.ResourceLogs { + l = MarshalProtoOrigResourceLogs(orig.ResourceLogs[i], buf[:pos]) + pos -= l + pos = proto.EncodeVarint(buf, pos, uint64(l)) + pos-- + buf[pos] = 0xa + } + return len(buf) - pos +} + +func UnmarshalProtoOrigExportLogsServiceRequest(orig *otlpcollectorlog.ExportLogsServiceRequest, buf []byte) error { + return orig.Unmarshal(buf) +} diff --git a/pdata/internal/generated_wrapper_exportlogsservicerequest_test.go b/pdata/internal/generated_wrapper_exportlogsservicerequest_test.go new file mode 100644 index 00000000000..a3a178f40cd --- /dev/null +++ b/pdata/internal/generated_wrapper_exportlogsservicerequest_test.go @@ -0,0 +1,71 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" + "go.opentelemetry.io/collector/pdata/internal/json" +) + +func TestCopyOrigExportLogsServiceRequest(t *testing.T) { + src := &otlpcollectorlog.ExportLogsServiceRequest{} + dest := &otlpcollectorlog.ExportLogsServiceRequest{} + CopyOrigExportLogsServiceRequest(dest, src) + assert.Equal(t, &otlpcollectorlog.ExportLogsServiceRequest{}, dest) + FillOrigTestExportLogsServiceRequest(src) + CopyOrigExportLogsServiceRequest(dest, src) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalJSONOrigExportLogsServiceRequest(t *testing.T) { + src := &otlpcollectorlog.ExportLogsServiceRequest{} + FillOrigTestExportLogsServiceRequest(src) + stream := json.BorrowStream(nil) + defer json.ReturnStream(stream) + MarshalJSONOrigExportLogsServiceRequest(src, stream) + require.NoError(t, stream.Error()) + + // Append an unknown field at the start to ensure unknown fields are skipped + // and the unmarshal logic continues. + buf := stream.Buffer() + assert.EqualValues(t, '{', buf[0]) + iter := json.BorrowIterator(append([]byte(`{"unknown": "string",`), buf[1:]...)) + defer json.ReturnIterator(iter) + dest := &otlpcollectorlog.ExportLogsServiceRequest{} + UnmarshalJSONOrigExportLogsServiceRequest(dest, iter) + require.NoError(t, iter.Error()) + + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigExportLogsServiceRequest(t *testing.T) { + src := &otlpcollectorlog.ExportLogsServiceRequest{} + FillOrigTestExportLogsServiceRequest(src) + buf := make([]byte, SizeProtoOrigExportLogsServiceRequest(src)) + gotSize := MarshalProtoOrigExportLogsServiceRequest(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectorlog.ExportLogsServiceRequest{} + require.NoError(t, UnmarshalProtoOrigExportLogsServiceRequest(dest, buf)) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigEmptyExportLogsServiceRequest(t *testing.T) { + src := &otlpcollectorlog.ExportLogsServiceRequest{} + buf := make([]byte, SizeProtoOrigExportLogsServiceRequest(src)) + gotSize := MarshalProtoOrigExportLogsServiceRequest(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectorlog.ExportLogsServiceRequest{} + require.NoError(t, UnmarshalProtoOrigExportLogsServiceRequest(dest, buf)) + assert.Equal(t, src, dest) +} diff --git a/pdata/internal/generated_wrapper_exportlogsserviceresponse.go b/pdata/internal/generated_wrapper_exportlogsserviceresponse.go new file mode 100644 index 00000000000..94c9c5f7bf5 --- /dev/null +++ b/pdata/internal/generated_wrapper_exportlogsserviceresponse.go @@ -0,0 +1,69 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" + "go.opentelemetry.io/collector/pdata/internal/json" + "go.opentelemetry.io/collector/pdata/internal/proto" +) + +func CopyOrigExportLogsServiceResponse(dest, src *otlpcollectorlog.ExportLogsServiceResponse) { + CopyOrigExportLogsPartialSuccess(&dest.PartialSuccess, &src.PartialSuccess) +} + +func FillOrigTestExportLogsServiceResponse(orig *otlpcollectorlog.ExportLogsServiceResponse) { + FillOrigTestExportLogsPartialSuccess(&orig.PartialSuccess) +} + +// MarshalJSONOrig marshals all properties from the current struct to the destination stream. +func MarshalJSONOrigExportLogsServiceResponse(orig *otlpcollectorlog.ExportLogsServiceResponse, dest *json.Stream) { + dest.WriteObjectStart() + dest.WriteObjectField("partialSuccess") + MarshalJSONOrigExportLogsPartialSuccess(&orig.PartialSuccess, dest) + dest.WriteObjectEnd() +} + +// UnmarshalJSONOrigExportResponse unmarshals all properties from the current struct from the source iterator. +func UnmarshalJSONOrigExportLogsServiceResponse(orig *otlpcollectorlog.ExportLogsServiceResponse, iter *json.Iterator) { + iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { + switch f { + case "partialSuccess", "partial_success": + UnmarshalJSONOrigExportLogsPartialSuccess(&orig.PartialSuccess, iter) + default: + iter.Skip() + } + return true + }) +} + +func SizeProtoOrigExportLogsServiceResponse(orig *otlpcollectorlog.ExportLogsServiceResponse) int { + var n int + var l int + _ = l + l = SizeProtoOrigExportLogsPartialSuccess(&orig.PartialSuccess) + n += 1 + proto.Sov(uint64(l)) + l + return n +} + +func MarshalProtoOrigExportLogsServiceResponse(orig *otlpcollectorlog.ExportLogsServiceResponse, buf []byte) int { + pos := len(buf) + var l int + _ = l + + l = MarshalProtoOrigExportLogsPartialSuccess(&orig.PartialSuccess, buf[:pos]) + pos -= l + pos = proto.EncodeVarint(buf, pos, uint64(l)) + pos-- + buf[pos] = 0xa + + return len(buf) - pos +} + +func UnmarshalProtoOrigExportLogsServiceResponse(orig *otlpcollectorlog.ExportLogsServiceResponse, buf []byte) error { + return orig.Unmarshal(buf) +} diff --git a/pdata/internal/generated_wrapper_exportlogsserviceresponse_test.go b/pdata/internal/generated_wrapper_exportlogsserviceresponse_test.go new file mode 100644 index 00000000000..3caa9468fae --- /dev/null +++ b/pdata/internal/generated_wrapper_exportlogsserviceresponse_test.go @@ -0,0 +1,71 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" + "go.opentelemetry.io/collector/pdata/internal/json" +) + +func TestCopyOrigExportLogsServiceResponse(t *testing.T) { + src := &otlpcollectorlog.ExportLogsServiceResponse{} + dest := &otlpcollectorlog.ExportLogsServiceResponse{} + CopyOrigExportLogsServiceResponse(dest, src) + assert.Equal(t, &otlpcollectorlog.ExportLogsServiceResponse{}, dest) + FillOrigTestExportLogsServiceResponse(src) + CopyOrigExportLogsServiceResponse(dest, src) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalJSONOrigExportLogsServiceResponse(t *testing.T) { + src := &otlpcollectorlog.ExportLogsServiceResponse{} + FillOrigTestExportLogsServiceResponse(src) + stream := json.BorrowStream(nil) + defer json.ReturnStream(stream) + MarshalJSONOrigExportLogsServiceResponse(src, stream) + require.NoError(t, stream.Error()) + + // Append an unknown field at the start to ensure unknown fields are skipped + // and the unmarshal logic continues. + buf := stream.Buffer() + assert.EqualValues(t, '{', buf[0]) + iter := json.BorrowIterator(append([]byte(`{"unknown": "string",`), buf[1:]...)) + defer json.ReturnIterator(iter) + dest := &otlpcollectorlog.ExportLogsServiceResponse{} + UnmarshalJSONOrigExportLogsServiceResponse(dest, iter) + require.NoError(t, iter.Error()) + + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigExportLogsServiceResponse(t *testing.T) { + src := &otlpcollectorlog.ExportLogsServiceResponse{} + FillOrigTestExportLogsServiceResponse(src) + buf := make([]byte, SizeProtoOrigExportLogsServiceResponse(src)) + gotSize := MarshalProtoOrigExportLogsServiceResponse(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectorlog.ExportLogsServiceResponse{} + require.NoError(t, UnmarshalProtoOrigExportLogsServiceResponse(dest, buf)) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigEmptyExportLogsServiceResponse(t *testing.T) { + src := &otlpcollectorlog.ExportLogsServiceResponse{} + buf := make([]byte, SizeProtoOrigExportLogsServiceResponse(src)) + gotSize := MarshalProtoOrigExportLogsServiceResponse(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectorlog.ExportLogsServiceResponse{} + require.NoError(t, UnmarshalProtoOrigExportLogsServiceResponse(dest, buf)) + assert.Equal(t, src, dest) +} diff --git a/pdata/internal/generated_wrapper_exportmetricsservicerequest.go b/pdata/internal/generated_wrapper_exportmetricsservicerequest.go new file mode 100644 index 00000000000..c5b09214904 --- /dev/null +++ b/pdata/internal/generated_wrapper_exportmetricsservicerequest.go @@ -0,0 +1,97 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" + "go.opentelemetry.io/collector/pdata/internal/json" + "go.opentelemetry.io/collector/pdata/internal/proto" +) + +type Metrics struct { + orig *otlpcollectormetrics.ExportMetricsServiceRequest + state *State +} + +func GetOrigMetrics(ms Metrics) *otlpcollectormetrics.ExportMetricsServiceRequest { + return ms.orig +} + +func GetMetricsState(ms Metrics) *State { + return ms.state +} + +func NewMetrics(orig *otlpcollectormetrics.ExportMetricsServiceRequest, state *State) Metrics { + return Metrics{orig: orig, state: state} +} + +func GenerateTestMetrics() Metrics { + orig := otlpcollectormetrics.ExportMetricsServiceRequest{} + FillOrigTestExportMetricsServiceRequest(&orig) + state := StateMutable + return NewMetrics(&orig, &state) +} + +func CopyOrigExportMetricsServiceRequest(dest, src *otlpcollectormetrics.ExportMetricsServiceRequest) { + dest.ResourceMetrics = CopyOrigResourceMetricsSlice(dest.ResourceMetrics, src.ResourceMetrics) +} + +func FillOrigTestExportMetricsServiceRequest(orig *otlpcollectormetrics.ExportMetricsServiceRequest) { + orig.ResourceMetrics = GenerateOrigTestResourceMetricsSlice() +} + +// MarshalJSONOrig marshals all properties from the current struct to the destination stream. +func MarshalJSONOrigExportMetricsServiceRequest(orig *otlpcollectormetrics.ExportMetricsServiceRequest, dest *json.Stream) { + dest.WriteObjectStart() + if len(orig.ResourceMetrics) > 0 { + dest.WriteObjectField("resourceMetrics") + MarshalJSONOrigResourceMetricsSlice(orig.ResourceMetrics, dest) + } + dest.WriteObjectEnd() +} + +// UnmarshalJSONOrigMetrics unmarshals all properties from the current struct from the source iterator. +func UnmarshalJSONOrigExportMetricsServiceRequest(orig *otlpcollectormetrics.ExportMetricsServiceRequest, iter *json.Iterator) { + iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { + switch f { + case "resourceMetrics", "resource_metrics": + orig.ResourceMetrics = UnmarshalJSONOrigResourceMetricsSlice(iter) + default: + iter.Skip() + } + return true + }) +} + +func SizeProtoOrigExportMetricsServiceRequest(orig *otlpcollectormetrics.ExportMetricsServiceRequest) int { + var n int + var l int + _ = l + for i := range orig.ResourceMetrics { + l = SizeProtoOrigResourceMetrics(orig.ResourceMetrics[i]) + n += 1 + proto.Sov(uint64(l)) + l + } + return n +} + +func MarshalProtoOrigExportMetricsServiceRequest(orig *otlpcollectormetrics.ExportMetricsServiceRequest, buf []byte) int { + pos := len(buf) + var l int + _ = l + for i := range orig.ResourceMetrics { + l = MarshalProtoOrigResourceMetrics(orig.ResourceMetrics[i], buf[:pos]) + pos -= l + pos = proto.EncodeVarint(buf, pos, uint64(l)) + pos-- + buf[pos] = 0xa + } + return len(buf) - pos +} + +func UnmarshalProtoOrigExportMetricsServiceRequest(orig *otlpcollectormetrics.ExportMetricsServiceRequest, buf []byte) error { + return orig.Unmarshal(buf) +} diff --git a/pdata/internal/generated_wrapper_exportmetricsservicerequest_test.go b/pdata/internal/generated_wrapper_exportmetricsservicerequest_test.go new file mode 100644 index 00000000000..6bffed09a74 --- /dev/null +++ b/pdata/internal/generated_wrapper_exportmetricsservicerequest_test.go @@ -0,0 +1,71 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" + "go.opentelemetry.io/collector/pdata/internal/json" +) + +func TestCopyOrigExportMetricsServiceRequest(t *testing.T) { + src := &otlpcollectormetrics.ExportMetricsServiceRequest{} + dest := &otlpcollectormetrics.ExportMetricsServiceRequest{} + CopyOrigExportMetricsServiceRequest(dest, src) + assert.Equal(t, &otlpcollectormetrics.ExportMetricsServiceRequest{}, dest) + FillOrigTestExportMetricsServiceRequest(src) + CopyOrigExportMetricsServiceRequest(dest, src) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceRequest(t *testing.T) { + src := &otlpcollectormetrics.ExportMetricsServiceRequest{} + FillOrigTestExportMetricsServiceRequest(src) + stream := json.BorrowStream(nil) + defer json.ReturnStream(stream) + MarshalJSONOrigExportMetricsServiceRequest(src, stream) + require.NoError(t, stream.Error()) + + // Append an unknown field at the start to ensure unknown fields are skipped + // and the unmarshal logic continues. + buf := stream.Buffer() + assert.EqualValues(t, '{', buf[0]) + iter := json.BorrowIterator(append([]byte(`{"unknown": "string",`), buf[1:]...)) + defer json.ReturnIterator(iter) + dest := &otlpcollectormetrics.ExportMetricsServiceRequest{} + UnmarshalJSONOrigExportMetricsServiceRequest(dest, iter) + require.NoError(t, iter.Error()) + + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigExportMetricsServiceRequest(t *testing.T) { + src := &otlpcollectormetrics.ExportMetricsServiceRequest{} + FillOrigTestExportMetricsServiceRequest(src) + buf := make([]byte, SizeProtoOrigExportMetricsServiceRequest(src)) + gotSize := MarshalProtoOrigExportMetricsServiceRequest(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectormetrics.ExportMetricsServiceRequest{} + require.NoError(t, UnmarshalProtoOrigExportMetricsServiceRequest(dest, buf)) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigEmptyExportMetricsServiceRequest(t *testing.T) { + src := &otlpcollectormetrics.ExportMetricsServiceRequest{} + buf := make([]byte, SizeProtoOrigExportMetricsServiceRequest(src)) + gotSize := MarshalProtoOrigExportMetricsServiceRequest(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectormetrics.ExportMetricsServiceRequest{} + require.NoError(t, UnmarshalProtoOrigExportMetricsServiceRequest(dest, buf)) + assert.Equal(t, src, dest) +} diff --git a/pdata/internal/generated_wrapper_exportmetricsserviceresponse.go b/pdata/internal/generated_wrapper_exportmetricsserviceresponse.go new file mode 100644 index 00000000000..6ca10962672 --- /dev/null +++ b/pdata/internal/generated_wrapper_exportmetricsserviceresponse.go @@ -0,0 +1,69 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" + "go.opentelemetry.io/collector/pdata/internal/json" + "go.opentelemetry.io/collector/pdata/internal/proto" +) + +func CopyOrigExportMetricsServiceResponse(dest, src *otlpcollectormetrics.ExportMetricsServiceResponse) { + CopyOrigExportMetricsPartialSuccess(&dest.PartialSuccess, &src.PartialSuccess) +} + +func FillOrigTestExportMetricsServiceResponse(orig *otlpcollectormetrics.ExportMetricsServiceResponse) { + FillOrigTestExportMetricsPartialSuccess(&orig.PartialSuccess) +} + +// MarshalJSONOrig marshals all properties from the current struct to the destination stream. +func MarshalJSONOrigExportMetricsServiceResponse(orig *otlpcollectormetrics.ExportMetricsServiceResponse, dest *json.Stream) { + dest.WriteObjectStart() + dest.WriteObjectField("partialSuccess") + MarshalJSONOrigExportMetricsPartialSuccess(&orig.PartialSuccess, dest) + dest.WriteObjectEnd() +} + +// UnmarshalJSONOrigExportResponse unmarshals all properties from the current struct from the source iterator. +func UnmarshalJSONOrigExportMetricsServiceResponse(orig *otlpcollectormetrics.ExportMetricsServiceResponse, iter *json.Iterator) { + iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { + switch f { + case "partialSuccess", "partial_success": + UnmarshalJSONOrigExportMetricsPartialSuccess(&orig.PartialSuccess, iter) + default: + iter.Skip() + } + return true + }) +} + +func SizeProtoOrigExportMetricsServiceResponse(orig *otlpcollectormetrics.ExportMetricsServiceResponse) int { + var n int + var l int + _ = l + l = SizeProtoOrigExportMetricsPartialSuccess(&orig.PartialSuccess) + n += 1 + proto.Sov(uint64(l)) + l + return n +} + +func MarshalProtoOrigExportMetricsServiceResponse(orig *otlpcollectormetrics.ExportMetricsServiceResponse, buf []byte) int { + pos := len(buf) + var l int + _ = l + + l = MarshalProtoOrigExportMetricsPartialSuccess(&orig.PartialSuccess, buf[:pos]) + pos -= l + pos = proto.EncodeVarint(buf, pos, uint64(l)) + pos-- + buf[pos] = 0xa + + return len(buf) - pos +} + +func UnmarshalProtoOrigExportMetricsServiceResponse(orig *otlpcollectormetrics.ExportMetricsServiceResponse, buf []byte) error { + return orig.Unmarshal(buf) +} diff --git a/pdata/internal/generated_wrapper_exportmetricsserviceresponse_test.go b/pdata/internal/generated_wrapper_exportmetricsserviceresponse_test.go new file mode 100644 index 00000000000..79d142c5155 --- /dev/null +++ b/pdata/internal/generated_wrapper_exportmetricsserviceresponse_test.go @@ -0,0 +1,71 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" + "go.opentelemetry.io/collector/pdata/internal/json" +) + +func TestCopyOrigExportMetricsServiceResponse(t *testing.T) { + src := &otlpcollectormetrics.ExportMetricsServiceResponse{} + dest := &otlpcollectormetrics.ExportMetricsServiceResponse{} + CopyOrigExportMetricsServiceResponse(dest, src) + assert.Equal(t, &otlpcollectormetrics.ExportMetricsServiceResponse{}, dest) + FillOrigTestExportMetricsServiceResponse(src) + CopyOrigExportMetricsServiceResponse(dest, src) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceResponse(t *testing.T) { + src := &otlpcollectormetrics.ExportMetricsServiceResponse{} + FillOrigTestExportMetricsServiceResponse(src) + stream := json.BorrowStream(nil) + defer json.ReturnStream(stream) + MarshalJSONOrigExportMetricsServiceResponse(src, stream) + require.NoError(t, stream.Error()) + + // Append an unknown field at the start to ensure unknown fields are skipped + // and the unmarshal logic continues. + buf := stream.Buffer() + assert.EqualValues(t, '{', buf[0]) + iter := json.BorrowIterator(append([]byte(`{"unknown": "string",`), buf[1:]...)) + defer json.ReturnIterator(iter) + dest := &otlpcollectormetrics.ExportMetricsServiceResponse{} + UnmarshalJSONOrigExportMetricsServiceResponse(dest, iter) + require.NoError(t, iter.Error()) + + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigExportMetricsServiceResponse(t *testing.T) { + src := &otlpcollectormetrics.ExportMetricsServiceResponse{} + FillOrigTestExportMetricsServiceResponse(src) + buf := make([]byte, SizeProtoOrigExportMetricsServiceResponse(src)) + gotSize := MarshalProtoOrigExportMetricsServiceResponse(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectormetrics.ExportMetricsServiceResponse{} + require.NoError(t, UnmarshalProtoOrigExportMetricsServiceResponse(dest, buf)) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigEmptyExportMetricsServiceResponse(t *testing.T) { + src := &otlpcollectormetrics.ExportMetricsServiceResponse{} + buf := make([]byte, SizeProtoOrigExportMetricsServiceResponse(src)) + gotSize := MarshalProtoOrigExportMetricsServiceResponse(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectormetrics.ExportMetricsServiceResponse{} + require.NoError(t, UnmarshalProtoOrigExportMetricsServiceResponse(dest, buf)) + assert.Equal(t, src, dest) +} diff --git a/pdata/internal/generated_wrapper_exportprofilesservicerequest.go b/pdata/internal/generated_wrapper_exportprofilesservicerequest.go new file mode 100644 index 00000000000..3bf6bae6cba --- /dev/null +++ b/pdata/internal/generated_wrapper_exportprofilesservicerequest.go @@ -0,0 +1,112 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" + "go.opentelemetry.io/collector/pdata/internal/json" + "go.opentelemetry.io/collector/pdata/internal/proto" +) + +type Profiles struct { + orig *otlpcollectorprofile.ExportProfilesServiceRequest + state *State +} + +func GetOrigProfiles(ms Profiles) *otlpcollectorprofile.ExportProfilesServiceRequest { + return ms.orig +} + +func GetProfilesState(ms Profiles) *State { + return ms.state +} + +func NewProfiles(orig *otlpcollectorprofile.ExportProfilesServiceRequest, state *State) Profiles { + return Profiles{orig: orig, state: state} +} + +func GenerateTestProfiles() Profiles { + orig := otlpcollectorprofile.ExportProfilesServiceRequest{} + FillOrigTestExportProfilesServiceRequest(&orig) + state := StateMutable + return NewProfiles(&orig, &state) +} + +func CopyOrigExportProfilesServiceRequest(dest, src *otlpcollectorprofile.ExportProfilesServiceRequest) { + dest.ResourceProfiles = CopyOrigResourceProfilesSlice(dest.ResourceProfiles, src.ResourceProfiles) + CopyOrigProfilesDictionary(&dest.Dictionary, &src.Dictionary) +} + +func FillOrigTestExportProfilesServiceRequest(orig *otlpcollectorprofile.ExportProfilesServiceRequest) { + orig.ResourceProfiles = GenerateOrigTestResourceProfilesSlice() + FillOrigTestProfilesDictionary(&orig.Dictionary) +} + +// MarshalJSONOrig marshals all properties from the current struct to the destination stream. +func MarshalJSONOrigExportProfilesServiceRequest(orig *otlpcollectorprofile.ExportProfilesServiceRequest, dest *json.Stream) { + dest.WriteObjectStart() + if len(orig.ResourceProfiles) > 0 { + dest.WriteObjectField("resourceProfiles") + MarshalJSONOrigResourceProfilesSlice(orig.ResourceProfiles, dest) + } + dest.WriteObjectField("dictionary") + MarshalJSONOrigProfilesDictionary(&orig.Dictionary, dest) + dest.WriteObjectEnd() +} + +// UnmarshalJSONOrigProfiles unmarshals all properties from the current struct from the source iterator. +func UnmarshalJSONOrigExportProfilesServiceRequest(orig *otlpcollectorprofile.ExportProfilesServiceRequest, iter *json.Iterator) { + iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { + switch f { + case "resourceProfiles", "resource_profiles": + orig.ResourceProfiles = UnmarshalJSONOrigResourceProfilesSlice(iter) + case "dictionary": + UnmarshalJSONOrigProfilesDictionary(&orig.Dictionary, iter) + default: + iter.Skip() + } + return true + }) +} + +func SizeProtoOrigExportProfilesServiceRequest(orig *otlpcollectorprofile.ExportProfilesServiceRequest) int { + var n int + var l int + _ = l + for i := range orig.ResourceProfiles { + l = SizeProtoOrigResourceProfiles(orig.ResourceProfiles[i]) + n += 1 + proto.Sov(uint64(l)) + l + } + l = SizeProtoOrigProfilesDictionary(&orig.Dictionary) + n += 1 + proto.Sov(uint64(l)) + l + return n +} + +func MarshalProtoOrigExportProfilesServiceRequest(orig *otlpcollectorprofile.ExportProfilesServiceRequest, buf []byte) int { + pos := len(buf) + var l int + _ = l + for i := range orig.ResourceProfiles { + l = MarshalProtoOrigResourceProfiles(orig.ResourceProfiles[i], buf[:pos]) + pos -= l + pos = proto.EncodeVarint(buf, pos, uint64(l)) + pos-- + buf[pos] = 0xa + } + + l = MarshalProtoOrigProfilesDictionary(&orig.Dictionary, buf[:pos]) + pos -= l + pos = proto.EncodeVarint(buf, pos, uint64(l)) + pos-- + buf[pos] = 0x12 + + return len(buf) - pos +} + +func UnmarshalProtoOrigExportProfilesServiceRequest(orig *otlpcollectorprofile.ExportProfilesServiceRequest, buf []byte) error { + return orig.Unmarshal(buf) +} diff --git a/pdata/internal/generated_wrapper_exportprofilesservicerequest_test.go b/pdata/internal/generated_wrapper_exportprofilesservicerequest_test.go new file mode 100644 index 00000000000..67f32d3a8af --- /dev/null +++ b/pdata/internal/generated_wrapper_exportprofilesservicerequest_test.go @@ -0,0 +1,71 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" + "go.opentelemetry.io/collector/pdata/internal/json" +) + +func TestCopyOrigExportProfilesServiceRequest(t *testing.T) { + src := &otlpcollectorprofile.ExportProfilesServiceRequest{} + dest := &otlpcollectorprofile.ExportProfilesServiceRequest{} + CopyOrigExportProfilesServiceRequest(dest, src) + assert.Equal(t, &otlpcollectorprofile.ExportProfilesServiceRequest{}, dest) + FillOrigTestExportProfilesServiceRequest(src) + CopyOrigExportProfilesServiceRequest(dest, src) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceRequest(t *testing.T) { + src := &otlpcollectorprofile.ExportProfilesServiceRequest{} + FillOrigTestExportProfilesServiceRequest(src) + stream := json.BorrowStream(nil) + defer json.ReturnStream(stream) + MarshalJSONOrigExportProfilesServiceRequest(src, stream) + require.NoError(t, stream.Error()) + + // Append an unknown field at the start to ensure unknown fields are skipped + // and the unmarshal logic continues. + buf := stream.Buffer() + assert.EqualValues(t, '{', buf[0]) + iter := json.BorrowIterator(append([]byte(`{"unknown": "string",`), buf[1:]...)) + defer json.ReturnIterator(iter) + dest := &otlpcollectorprofile.ExportProfilesServiceRequest{} + UnmarshalJSONOrigExportProfilesServiceRequest(dest, iter) + require.NoError(t, iter.Error()) + + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigExportProfilesServiceRequest(t *testing.T) { + src := &otlpcollectorprofile.ExportProfilesServiceRequest{} + FillOrigTestExportProfilesServiceRequest(src) + buf := make([]byte, SizeProtoOrigExportProfilesServiceRequest(src)) + gotSize := MarshalProtoOrigExportProfilesServiceRequest(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectorprofile.ExportProfilesServiceRequest{} + require.NoError(t, UnmarshalProtoOrigExportProfilesServiceRequest(dest, buf)) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigEmptyExportProfilesServiceRequest(t *testing.T) { + src := &otlpcollectorprofile.ExportProfilesServiceRequest{} + buf := make([]byte, SizeProtoOrigExportProfilesServiceRequest(src)) + gotSize := MarshalProtoOrigExportProfilesServiceRequest(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectorprofile.ExportProfilesServiceRequest{} + require.NoError(t, UnmarshalProtoOrigExportProfilesServiceRequest(dest, buf)) + assert.Equal(t, src, dest) +} diff --git a/pdata/internal/generated_wrapper_exportprofilesserviceresponse.go b/pdata/internal/generated_wrapper_exportprofilesserviceresponse.go new file mode 100644 index 00000000000..80b6fe8f653 --- /dev/null +++ b/pdata/internal/generated_wrapper_exportprofilesserviceresponse.go @@ -0,0 +1,69 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" + "go.opentelemetry.io/collector/pdata/internal/json" + "go.opentelemetry.io/collector/pdata/internal/proto" +) + +func CopyOrigExportProfilesServiceResponse(dest, src *otlpcollectorprofile.ExportProfilesServiceResponse) { + CopyOrigExportProfilesPartialSuccess(&dest.PartialSuccess, &src.PartialSuccess) +} + +func FillOrigTestExportProfilesServiceResponse(orig *otlpcollectorprofile.ExportProfilesServiceResponse) { + FillOrigTestExportProfilesPartialSuccess(&orig.PartialSuccess) +} + +// MarshalJSONOrig marshals all properties from the current struct to the destination stream. +func MarshalJSONOrigExportProfilesServiceResponse(orig *otlpcollectorprofile.ExportProfilesServiceResponse, dest *json.Stream) { + dest.WriteObjectStart() + dest.WriteObjectField("partialSuccess") + MarshalJSONOrigExportProfilesPartialSuccess(&orig.PartialSuccess, dest) + dest.WriteObjectEnd() +} + +// UnmarshalJSONOrigExportResponse unmarshals all properties from the current struct from the source iterator. +func UnmarshalJSONOrigExportProfilesServiceResponse(orig *otlpcollectorprofile.ExportProfilesServiceResponse, iter *json.Iterator) { + iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { + switch f { + case "partialSuccess", "partial_success": + UnmarshalJSONOrigExportProfilesPartialSuccess(&orig.PartialSuccess, iter) + default: + iter.Skip() + } + return true + }) +} + +func SizeProtoOrigExportProfilesServiceResponse(orig *otlpcollectorprofile.ExportProfilesServiceResponse) int { + var n int + var l int + _ = l + l = SizeProtoOrigExportProfilesPartialSuccess(&orig.PartialSuccess) + n += 1 + proto.Sov(uint64(l)) + l + return n +} + +func MarshalProtoOrigExportProfilesServiceResponse(orig *otlpcollectorprofile.ExportProfilesServiceResponse, buf []byte) int { + pos := len(buf) + var l int + _ = l + + l = MarshalProtoOrigExportProfilesPartialSuccess(&orig.PartialSuccess, buf[:pos]) + pos -= l + pos = proto.EncodeVarint(buf, pos, uint64(l)) + pos-- + buf[pos] = 0xa + + return len(buf) - pos +} + +func UnmarshalProtoOrigExportProfilesServiceResponse(orig *otlpcollectorprofile.ExportProfilesServiceResponse, buf []byte) error { + return orig.Unmarshal(buf) +} diff --git a/pdata/internal/generated_wrapper_exportprofilesserviceresponse_test.go b/pdata/internal/generated_wrapper_exportprofilesserviceresponse_test.go new file mode 100644 index 00000000000..bac24f15b15 --- /dev/null +++ b/pdata/internal/generated_wrapper_exportprofilesserviceresponse_test.go @@ -0,0 +1,71 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" + "go.opentelemetry.io/collector/pdata/internal/json" +) + +func TestCopyOrigExportProfilesServiceResponse(t *testing.T) { + src := &otlpcollectorprofile.ExportProfilesServiceResponse{} + dest := &otlpcollectorprofile.ExportProfilesServiceResponse{} + CopyOrigExportProfilesServiceResponse(dest, src) + assert.Equal(t, &otlpcollectorprofile.ExportProfilesServiceResponse{}, dest) + FillOrigTestExportProfilesServiceResponse(src) + CopyOrigExportProfilesServiceResponse(dest, src) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceResponse(t *testing.T) { + src := &otlpcollectorprofile.ExportProfilesServiceResponse{} + FillOrigTestExportProfilesServiceResponse(src) + stream := json.BorrowStream(nil) + defer json.ReturnStream(stream) + MarshalJSONOrigExportProfilesServiceResponse(src, stream) + require.NoError(t, stream.Error()) + + // Append an unknown field at the start to ensure unknown fields are skipped + // and the unmarshal logic continues. + buf := stream.Buffer() + assert.EqualValues(t, '{', buf[0]) + iter := json.BorrowIterator(append([]byte(`{"unknown": "string",`), buf[1:]...)) + defer json.ReturnIterator(iter) + dest := &otlpcollectorprofile.ExportProfilesServiceResponse{} + UnmarshalJSONOrigExportProfilesServiceResponse(dest, iter) + require.NoError(t, iter.Error()) + + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigExportProfilesServiceResponse(t *testing.T) { + src := &otlpcollectorprofile.ExportProfilesServiceResponse{} + FillOrigTestExportProfilesServiceResponse(src) + buf := make([]byte, SizeProtoOrigExportProfilesServiceResponse(src)) + gotSize := MarshalProtoOrigExportProfilesServiceResponse(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectorprofile.ExportProfilesServiceResponse{} + require.NoError(t, UnmarshalProtoOrigExportProfilesServiceResponse(dest, buf)) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigEmptyExportProfilesServiceResponse(t *testing.T) { + src := &otlpcollectorprofile.ExportProfilesServiceResponse{} + buf := make([]byte, SizeProtoOrigExportProfilesServiceResponse(src)) + gotSize := MarshalProtoOrigExportProfilesServiceResponse(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectorprofile.ExportProfilesServiceResponse{} + require.NoError(t, UnmarshalProtoOrigExportProfilesServiceResponse(dest, buf)) + assert.Equal(t, src, dest) +} diff --git a/pdata/internal/generated_wrapper_exporttraceservicerequest.go b/pdata/internal/generated_wrapper_exporttraceservicerequest.go new file mode 100644 index 00000000000..d83bf82a06d --- /dev/null +++ b/pdata/internal/generated_wrapper_exporttraceservicerequest.go @@ -0,0 +1,97 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" + "go.opentelemetry.io/collector/pdata/internal/json" + "go.opentelemetry.io/collector/pdata/internal/proto" +) + +type Traces struct { + orig *otlpcollectortrace.ExportTraceServiceRequest + state *State +} + +func GetOrigTraces(ms Traces) *otlpcollectortrace.ExportTraceServiceRequest { + return ms.orig +} + +func GetTracesState(ms Traces) *State { + return ms.state +} + +func NewTraces(orig *otlpcollectortrace.ExportTraceServiceRequest, state *State) Traces { + return Traces{orig: orig, state: state} +} + +func GenerateTestTraces() Traces { + orig := otlpcollectortrace.ExportTraceServiceRequest{} + FillOrigTestExportTraceServiceRequest(&orig) + state := StateMutable + return NewTraces(&orig, &state) +} + +func CopyOrigExportTraceServiceRequest(dest, src *otlpcollectortrace.ExportTraceServiceRequest) { + dest.ResourceSpans = CopyOrigResourceSpansSlice(dest.ResourceSpans, src.ResourceSpans) +} + +func FillOrigTestExportTraceServiceRequest(orig *otlpcollectortrace.ExportTraceServiceRequest) { + orig.ResourceSpans = GenerateOrigTestResourceSpansSlice() +} + +// MarshalJSONOrig marshals all properties from the current struct to the destination stream. +func MarshalJSONOrigExportTraceServiceRequest(orig *otlpcollectortrace.ExportTraceServiceRequest, dest *json.Stream) { + dest.WriteObjectStart() + if len(orig.ResourceSpans) > 0 { + dest.WriteObjectField("resourceSpans") + MarshalJSONOrigResourceSpansSlice(orig.ResourceSpans, dest) + } + dest.WriteObjectEnd() +} + +// UnmarshalJSONOrigTraces unmarshals all properties from the current struct from the source iterator. +func UnmarshalJSONOrigExportTraceServiceRequest(orig *otlpcollectortrace.ExportTraceServiceRequest, iter *json.Iterator) { + iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { + switch f { + case "resourceSpans", "resource_spans": + orig.ResourceSpans = UnmarshalJSONOrigResourceSpansSlice(iter) + default: + iter.Skip() + } + return true + }) +} + +func SizeProtoOrigExportTraceServiceRequest(orig *otlpcollectortrace.ExportTraceServiceRequest) int { + var n int + var l int + _ = l + for i := range orig.ResourceSpans { + l = SizeProtoOrigResourceSpans(orig.ResourceSpans[i]) + n += 1 + proto.Sov(uint64(l)) + l + } + return n +} + +func MarshalProtoOrigExportTraceServiceRequest(orig *otlpcollectortrace.ExportTraceServiceRequest, buf []byte) int { + pos := len(buf) + var l int + _ = l + for i := range orig.ResourceSpans { + l = MarshalProtoOrigResourceSpans(orig.ResourceSpans[i], buf[:pos]) + pos -= l + pos = proto.EncodeVarint(buf, pos, uint64(l)) + pos-- + buf[pos] = 0xa + } + return len(buf) - pos +} + +func UnmarshalProtoOrigExportTraceServiceRequest(orig *otlpcollectortrace.ExportTraceServiceRequest, buf []byte) error { + return orig.Unmarshal(buf) +} diff --git a/pdata/internal/generated_wrapper_exporttraceservicerequest_test.go b/pdata/internal/generated_wrapper_exporttraceservicerequest_test.go new file mode 100644 index 00000000000..2be45faba50 --- /dev/null +++ b/pdata/internal/generated_wrapper_exporttraceservicerequest_test.go @@ -0,0 +1,71 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" + "go.opentelemetry.io/collector/pdata/internal/json" +) + +func TestCopyOrigExportTraceServiceRequest(t *testing.T) { + src := &otlpcollectortrace.ExportTraceServiceRequest{} + dest := &otlpcollectortrace.ExportTraceServiceRequest{} + CopyOrigExportTraceServiceRequest(dest, src) + assert.Equal(t, &otlpcollectortrace.ExportTraceServiceRequest{}, dest) + FillOrigTestExportTraceServiceRequest(src) + CopyOrigExportTraceServiceRequest(dest, src) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalJSONOrigExportTraceServiceRequest(t *testing.T) { + src := &otlpcollectortrace.ExportTraceServiceRequest{} + FillOrigTestExportTraceServiceRequest(src) + stream := json.BorrowStream(nil) + defer json.ReturnStream(stream) + MarshalJSONOrigExportTraceServiceRequest(src, stream) + require.NoError(t, stream.Error()) + + // Append an unknown field at the start to ensure unknown fields are skipped + // and the unmarshal logic continues. + buf := stream.Buffer() + assert.EqualValues(t, '{', buf[0]) + iter := json.BorrowIterator(append([]byte(`{"unknown": "string",`), buf[1:]...)) + defer json.ReturnIterator(iter) + dest := &otlpcollectortrace.ExportTraceServiceRequest{} + UnmarshalJSONOrigExportTraceServiceRequest(dest, iter) + require.NoError(t, iter.Error()) + + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigExportTraceServiceRequest(t *testing.T) { + src := &otlpcollectortrace.ExportTraceServiceRequest{} + FillOrigTestExportTraceServiceRequest(src) + buf := make([]byte, SizeProtoOrigExportTraceServiceRequest(src)) + gotSize := MarshalProtoOrigExportTraceServiceRequest(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectortrace.ExportTraceServiceRequest{} + require.NoError(t, UnmarshalProtoOrigExportTraceServiceRequest(dest, buf)) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigEmptyExportTraceServiceRequest(t *testing.T) { + src := &otlpcollectortrace.ExportTraceServiceRequest{} + buf := make([]byte, SizeProtoOrigExportTraceServiceRequest(src)) + gotSize := MarshalProtoOrigExportTraceServiceRequest(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectortrace.ExportTraceServiceRequest{} + require.NoError(t, UnmarshalProtoOrigExportTraceServiceRequest(dest, buf)) + assert.Equal(t, src, dest) +} diff --git a/pdata/internal/generated_wrapper_exporttraceserviceresponse.go b/pdata/internal/generated_wrapper_exporttraceserviceresponse.go new file mode 100644 index 00000000000..010fa7df012 --- /dev/null +++ b/pdata/internal/generated_wrapper_exporttraceserviceresponse.go @@ -0,0 +1,69 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" + "go.opentelemetry.io/collector/pdata/internal/json" + "go.opentelemetry.io/collector/pdata/internal/proto" +) + +func CopyOrigExportTraceServiceResponse(dest, src *otlpcollectortrace.ExportTraceServiceResponse) { + CopyOrigExportTracePartialSuccess(&dest.PartialSuccess, &src.PartialSuccess) +} + +func FillOrigTestExportTraceServiceResponse(orig *otlpcollectortrace.ExportTraceServiceResponse) { + FillOrigTestExportTracePartialSuccess(&orig.PartialSuccess) +} + +// MarshalJSONOrig marshals all properties from the current struct to the destination stream. +func MarshalJSONOrigExportTraceServiceResponse(orig *otlpcollectortrace.ExportTraceServiceResponse, dest *json.Stream) { + dest.WriteObjectStart() + dest.WriteObjectField("partialSuccess") + MarshalJSONOrigExportTracePartialSuccess(&orig.PartialSuccess, dest) + dest.WriteObjectEnd() +} + +// UnmarshalJSONOrigExportResponse unmarshals all properties from the current struct from the source iterator. +func UnmarshalJSONOrigExportTraceServiceResponse(orig *otlpcollectortrace.ExportTraceServiceResponse, iter *json.Iterator) { + iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { + switch f { + case "partialSuccess", "partial_success": + UnmarshalJSONOrigExportTracePartialSuccess(&orig.PartialSuccess, iter) + default: + iter.Skip() + } + return true + }) +} + +func SizeProtoOrigExportTraceServiceResponse(orig *otlpcollectortrace.ExportTraceServiceResponse) int { + var n int + var l int + _ = l + l = SizeProtoOrigExportTracePartialSuccess(&orig.PartialSuccess) + n += 1 + proto.Sov(uint64(l)) + l + return n +} + +func MarshalProtoOrigExportTraceServiceResponse(orig *otlpcollectortrace.ExportTraceServiceResponse, buf []byte) int { + pos := len(buf) + var l int + _ = l + + l = MarshalProtoOrigExportTracePartialSuccess(&orig.PartialSuccess, buf[:pos]) + pos -= l + pos = proto.EncodeVarint(buf, pos, uint64(l)) + pos-- + buf[pos] = 0xa + + return len(buf) - pos +} + +func UnmarshalProtoOrigExportTraceServiceResponse(orig *otlpcollectortrace.ExportTraceServiceResponse, buf []byte) error { + return orig.Unmarshal(buf) +} diff --git a/pdata/internal/generated_wrapper_exporttraceserviceresponse_test.go b/pdata/internal/generated_wrapper_exporttraceserviceresponse_test.go new file mode 100644 index 00000000000..124861c558b --- /dev/null +++ b/pdata/internal/generated_wrapper_exporttraceserviceresponse_test.go @@ -0,0 +1,71 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" + "go.opentelemetry.io/collector/pdata/internal/json" +) + +func TestCopyOrigExportTraceServiceResponse(t *testing.T) { + src := &otlpcollectortrace.ExportTraceServiceResponse{} + dest := &otlpcollectortrace.ExportTraceServiceResponse{} + CopyOrigExportTraceServiceResponse(dest, src) + assert.Equal(t, &otlpcollectortrace.ExportTraceServiceResponse{}, dest) + FillOrigTestExportTraceServiceResponse(src) + CopyOrigExportTraceServiceResponse(dest, src) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalJSONOrigExportTraceServiceResponse(t *testing.T) { + src := &otlpcollectortrace.ExportTraceServiceResponse{} + FillOrigTestExportTraceServiceResponse(src) + stream := json.BorrowStream(nil) + defer json.ReturnStream(stream) + MarshalJSONOrigExportTraceServiceResponse(src, stream) + require.NoError(t, stream.Error()) + + // Append an unknown field at the start to ensure unknown fields are skipped + // and the unmarshal logic continues. + buf := stream.Buffer() + assert.EqualValues(t, '{', buf[0]) + iter := json.BorrowIterator(append([]byte(`{"unknown": "string",`), buf[1:]...)) + defer json.ReturnIterator(iter) + dest := &otlpcollectortrace.ExportTraceServiceResponse{} + UnmarshalJSONOrigExportTraceServiceResponse(dest, iter) + require.NoError(t, iter.Error()) + + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigExportTraceServiceResponse(t *testing.T) { + src := &otlpcollectortrace.ExportTraceServiceResponse{} + FillOrigTestExportTraceServiceResponse(src) + buf := make([]byte, SizeProtoOrigExportTraceServiceResponse(src)) + gotSize := MarshalProtoOrigExportTraceServiceResponse(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectortrace.ExportTraceServiceResponse{} + require.NoError(t, UnmarshalProtoOrigExportTraceServiceResponse(dest, buf)) + assert.Equal(t, src, dest) +} + +func TestMarshalAndUnmarshalProtoOrigEmptyExportTraceServiceResponse(t *testing.T) { + src := &otlpcollectortrace.ExportTraceServiceResponse{} + buf := make([]byte, SizeProtoOrigExportTraceServiceResponse(src)) + gotSize := MarshalProtoOrigExportTraceServiceResponse(src, buf) + assert.Equal(t, len(buf), gotSize) + + dest := &otlpcollectortrace.ExportTraceServiceResponse{} + require.NoError(t, UnmarshalProtoOrigExportTraceServiceResponse(dest, buf)) + assert.Equal(t, src, dest) +} diff --git a/pdata/internal/wrapper_logs.go b/pdata/internal/wrapper_logs.go index 6b6c076cca6..e308209bbf2 100644 --- a/pdata/internal/wrapper_logs.go +++ b/pdata/internal/wrapper_logs.go @@ -8,27 +8,10 @@ import ( otlplogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/logs/v1" ) -type Logs struct { - orig *otlpcollectorlog.ExportLogsServiceRequest - state *State -} - -func GetOrigLogs(ms Logs) *otlpcollectorlog.ExportLogsServiceRequest { - return ms.orig -} - -func GetLogsState(ms Logs) *State { - return ms.state -} - func SetLogsState(ms Logs, state State) { *ms.state = state } -func NewLogs(orig *otlpcollectorlog.ExportLogsServiceRequest, state *State) Logs { - return Logs{orig: orig, state: state} -} - // LogsToProto internal helper to convert Logs to protobuf representation. func LogsToProto(l Logs) otlplogs.LogsData { return otlplogs.LogsData{ diff --git a/pdata/internal/wrapper_metrics.go b/pdata/internal/wrapper_metrics.go index 85be497ea5c..ac34c5628c7 100644 --- a/pdata/internal/wrapper_metrics.go +++ b/pdata/internal/wrapper_metrics.go @@ -8,27 +8,10 @@ import ( otlpmetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/metrics/v1" ) -type Metrics struct { - orig *otlpcollectormetrics.ExportMetricsServiceRequest - state *State -} - -func GetOrigMetrics(ms Metrics) *otlpcollectormetrics.ExportMetricsServiceRequest { - return ms.orig -} - -func GetMetricsState(ms Metrics) *State { - return ms.state -} - func SetMetricsState(ms Metrics, state State) { *ms.state = state } -func NewMetrics(orig *otlpcollectormetrics.ExportMetricsServiceRequest, state *State) Metrics { - return Metrics{orig: orig, state: state} -} - // MetricsToProto internal helper to convert Metrics to protobuf representation. func MetricsToProto(l Metrics) otlpmetrics.MetricsData { return otlpmetrics.MetricsData{ diff --git a/pdata/internal/wrapper_profiles.go b/pdata/internal/wrapper_profiles.go index 5b5f0cc06ef..0e47d67020f 100644 --- a/pdata/internal/wrapper_profiles.go +++ b/pdata/internal/wrapper_profiles.go @@ -8,27 +8,10 @@ import ( otlpprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/profiles/v1development" ) -type Profiles struct { - orig *otlpcollectorprofile.ExportProfilesServiceRequest - state *State -} - -func GetOrigProfiles(ms Profiles) *otlpcollectorprofile.ExportProfilesServiceRequest { - return ms.orig -} - -func GetProfilesState(ms Profiles) *State { - return ms.state -} - func SetProfilesState(ms Profiles, state State) { *ms.state = state } -func NewProfiles(orig *otlpcollectorprofile.ExportProfilesServiceRequest, state *State) Profiles { - return Profiles{orig: orig, state: state} -} - // ProfilesToProto internal helper to convert Profiles to protobuf representation. func ProfilesToProto(l Profiles) otlpprofile.ProfilesData { return otlpprofile.ProfilesData{ diff --git a/pdata/internal/wrapper_traces.go b/pdata/internal/wrapper_traces.go index 5a4cdadbde0..399e8691669 100644 --- a/pdata/internal/wrapper_traces.go +++ b/pdata/internal/wrapper_traces.go @@ -8,27 +8,10 @@ import ( otlptrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/trace/v1" ) -type Traces struct { - orig *otlpcollectortrace.ExportTraceServiceRequest - state *State -} - -func GetOrigTraces(ms Traces) *otlpcollectortrace.ExportTraceServiceRequest { - return ms.orig -} - -func GetTracesState(ms Traces) *State { - return ms.state -} - func SetTracesState(ms Traces, state State) { *ms.state = state } -func NewTraces(orig *otlpcollectortrace.ExportTraceServiceRequest, state *State) Traces { - return Traces{orig: orig, state: state} -} - // TracesToProto internal helper to convert Traces to protobuf representation. func TracesToProto(l Traces) otlptrace.TracesData { return otlptrace.TracesData{ diff --git a/pdata/plog/generated_logs.go b/pdata/plog/generated_logs.go new file mode 100644 index 00000000000..144a9915eea --- /dev/null +++ b/pdata/plog/generated_logs.go @@ -0,0 +1,67 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package plog + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" +) + +// Logs is the top-level struct that is propagated through the logs pipeline. +// Use NewLogs to create new instance, zero-initialized instance is not valid for use. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewLogs function to create new instances. +// Important: zero-initialized instance is not valid for use. +type Logs internal.Logs + +func newLogs(orig *otlpcollectorlog.ExportLogsServiceRequest, state *internal.State) Logs { + return Logs(internal.NewLogs(orig, state)) +} + +// NewLogs creates a new empty Logs. +// +// This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice, +// OR directly access the member if this is embedded in another struct. +func NewLogs() Logs { + state := internal.StateMutable + return newLogs(&otlpcollectorlog.ExportLogsServiceRequest{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms Logs) MoveTo(dest Logs) { + ms.getState().AssertMutable() + dest.getState().AssertMutable() + // If they point to the same data, they are the same, nothing to do. + if ms.getOrig() == dest.getOrig() { + return + } + *dest.getOrig() = *ms.getOrig() + *ms.getOrig() = otlpcollectorlog.ExportLogsServiceRequest{} +} + +// ResourceLogs returns the ResourceLogs associated with this Logs. +func (ms Logs) ResourceLogs() ResourceLogsSlice { + return newResourceLogsSlice(&ms.getOrig().ResourceLogs, ms.getState()) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms Logs) CopyTo(dest Logs) { + dest.getState().AssertMutable() + internal.CopyOrigExportLogsServiceRequest(dest.getOrig(), ms.getOrig()) +} + +func (ms Logs) getOrig() *otlpcollectorlog.ExportLogsServiceRequest { + return internal.GetOrigLogs(internal.Logs(ms)) +} + +func (ms Logs) getState() *internal.State { + return internal.GetLogsState(internal.Logs(ms)) +} diff --git a/pdata/plog/generated_logs_test.go b/pdata/plog/generated_logs_test.go new file mode 100644 index 00000000000..f4bc1a0c8d0 --- /dev/null +++ b/pdata/plog/generated_logs_test.go @@ -0,0 +1,52 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package plog + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" +) + +func TestLogs_MoveTo(t *testing.T) { + ms := generateTestLogs() + dest := NewLogs() + ms.MoveTo(dest) + assert.Equal(t, NewLogs(), ms) + assert.Equal(t, generateTestLogs(), dest) + dest.MoveTo(dest) + assert.Equal(t, generateTestLogs(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newLogs(&otlpcollectorlog.ExportLogsServiceRequest{}, &sharedState)) }) + assert.Panics(t, func() { newLogs(&otlpcollectorlog.ExportLogsServiceRequest{}, &sharedState).MoveTo(dest) }) +} + +func TestLogs_CopyTo(t *testing.T) { + ms := NewLogs() + orig := NewLogs() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestLogs() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newLogs(&otlpcollectorlog.ExportLogsServiceRequest{}, &sharedState)) }) +} + +func TestLogs_ResourceLogs(t *testing.T) { + ms := NewLogs() + assert.Equal(t, NewResourceLogsSlice(), ms.ResourceLogs()) + ms.getOrig().ResourceLogs = internal.GenerateOrigTestResourceLogsSlice() + assert.Equal(t, generateTestResourceLogsSlice(), ms.ResourceLogs()) +} + +func generateTestLogs() Logs { + return Logs(internal.GenerateTestLogs()) +} diff --git a/pdata/plog/json.go b/pdata/plog/json.go index ea449870311..362ee3df3a7 100644 --- a/pdata/plog/json.go +++ b/pdata/plog/json.go @@ -6,6 +6,7 @@ package plog // import "go.opentelemetry.io/collector/pdata/plog" import ( "slices" + "go.opentelemetry.io/collector/pdata/internal" "go.opentelemetry.io/collector/pdata/internal/json" "go.opentelemetry.io/collector/pdata/internal/otlp" ) @@ -17,7 +18,7 @@ type JSONMarshaler struct{} func (*JSONMarshaler) MarshalLogs(ld Logs) ([]byte, error) { dest := json.BorrowStream(nil) defer json.ReturnStream(dest) - ld.marshalJSONStream(dest) + internal.MarshalJSONOrigExportLogsServiceRequest(ld.getOrig(), dest) if dest.Error() != nil { return nil, dest.Error() } @@ -34,7 +35,7 @@ func (*JSONUnmarshaler) UnmarshalLogs(buf []byte) (Logs, error) { iter := json.BorrowIterator(buf) defer json.ReturnIterator(iter) ld := NewLogs() - ld.unmarshalJSONIter(iter) + internal.UnmarshalJSONOrigExportLogsServiceRequest(ld.getOrig(), iter) if iter.Error() != nil { return Logs{}, iter.Error() } diff --git a/pdata/plog/logs.go b/pdata/plog/logs.go index 174a92fb231..08f71a04130 100644 --- a/pdata/plog/logs.go +++ b/pdata/plog/logs.go @@ -5,30 +5,11 @@ package plog // import "go.opentelemetry.io/collector/pdata/plog" import ( "go.opentelemetry.io/collector/pdata/internal" - otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" - "go.opentelemetry.io/collector/pdata/internal/json" ) -// Logs is the top-level struct that is propagated through the logs pipeline. -// Use NewLogs to create new instance, zero-initialized instance is not valid for use. -type Logs internal.Logs - -func newLogs(orig *otlpcollectorlog.ExportLogsServiceRequest) Logs { - state := internal.StateMutable - return Logs(internal.NewLogs(orig, &state)) -} - -func (ms Logs) getOrig() *otlpcollectorlog.ExportLogsServiceRequest { - return internal.GetOrigLogs(internal.Logs(ms)) -} - -func (ms Logs) getState() *internal.State { - return internal.GetLogsState(internal.Logs(ms)) -} - -// NewLogs creates a new Logs struct. -func NewLogs() Logs { - return newLogs(&otlpcollectorlog.ExportLogsServiceRequest{}) +// MarkReadOnly marks the Logs as shared so that no further modifications can be done on it. +func (ms Logs) MarkReadOnly() { + internal.SetLogsState(internal.Logs(ms), internal.StateReadOnly) } // IsReadOnly returns true if this Logs instance is read-only. @@ -36,11 +17,6 @@ func (ms Logs) IsReadOnly() bool { return *ms.getState() == internal.StateReadOnly } -// CopyTo copies the Logs instance overriding the destination. -func (ms Logs) CopyTo(dest Logs) { - ms.ResourceLogs().CopyTo(dest.ResourceLogs()) -} - // LogRecordCount calculates the total number of log records. func (ms Logs) LogRecordCount() int { logCount := 0 @@ -55,34 +31,3 @@ func (ms Logs) LogRecordCount() int { } return logCount } - -// ResourceLogs returns the ResourceLogsSlice associated with this Logs. -func (ms Logs) ResourceLogs() ResourceLogsSlice { - return newResourceLogsSlice(&ms.getOrig().ResourceLogs, internal.GetLogsState(internal.Logs(ms))) -} - -// MarkReadOnly marks the Logs as shared so that no further modifications can be done on it. -func (ms Logs) MarkReadOnly() { - internal.SetLogsState(internal.Logs(ms), internal.StateReadOnly) -} - -func (ms Logs) marshalJSONStream(dest *json.Stream) { - dest.WriteObjectStart() - if len(ms.getOrig().ResourceLogs) > 0 { - dest.WriteObjectField("resourceLogs") - internal.MarshalJSONOrigResourceLogsSlice(ms.getOrig().ResourceLogs, dest) - } - dest.WriteObjectEnd() -} - -func (ms Logs) unmarshalJSONIter(iter *json.Iterator) { - iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { - switch f { - case "resource_logs", "resourceLogs": - ms.getOrig().ResourceLogs = internal.UnmarshalJSONOrigResourceLogsSlice(iter) - default: - iter.Skip() - } - return true - }) -} diff --git a/pdata/plog/logs_test.go b/pdata/plog/logs_test.go index b8909e46297..f633b820fbc 100644 --- a/pdata/plog/logs_test.go +++ b/pdata/plog/logs_test.go @@ -47,14 +47,14 @@ func TestLogRecordCountWithEmpty(t *testing.T) { assert.Zero(t, NewLogs().LogRecordCount()) assert.Zero(t, newLogs(&otlpcollectorlog.ExportLogsServiceRequest{ ResourceLogs: []*otlplogs.ResourceLogs{{}}, - }).LogRecordCount()) + }, new(internal.State)).LogRecordCount()) assert.Zero(t, newLogs(&otlpcollectorlog.ExportLogsServiceRequest{ ResourceLogs: []*otlplogs.ResourceLogs{ { ScopeLogs: []*otlplogs.ScopeLogs{{}}, }, }, - }).LogRecordCount()) + }, new(internal.State)).LogRecordCount()) assert.Equal(t, 1, newLogs(&otlpcollectorlog.ExportLogsServiceRequest{ ResourceLogs: []*otlplogs.ResourceLogs{ { @@ -65,14 +65,7 @@ func TestLogRecordCountWithEmpty(t *testing.T) { }, }, }, - }).LogRecordCount()) -} - -func TestToFromLogOtlp(t *testing.T) { - otlp := &otlpcollectorlog.ExportLogsServiceRequest{} - logs := newLogs(otlp) - assert.Equal(t, NewLogs(), logs) - assert.Equal(t, otlp, logs.getOrig()) + }, new(internal.State)).LogRecordCount()) } func TestResourceLogsWireCompatibility(t *testing.T) { @@ -108,13 +101,6 @@ func TestResourceLogsWireCompatibility(t *testing.T) { assert.Equal(t, ms.getOrig(), &gogoprotoRS2) } -func TestLogsCopyTo(t *testing.T) { - ld := generateTestLogs() - logsCopy := NewLogs() - ld.CopyTo(logsCopy) - assert.Equal(t, ld, logsCopy) -} - func TestReadOnlyLogsInvalidUsage(t *testing.T) { ld := NewLogs() assert.False(t, ld.IsReadOnly()) @@ -183,9 +169,3 @@ func BenchmarkLogsMarshalJSON(b *testing.B) { require.NotNil(b, jsonBuf) } } - -func generateTestLogs() Logs { - ld := NewLogs() - ld.getOrig().ResourceLogs = internal.GenerateOrigTestResourceLogsSlice() - return ld -} diff --git a/pdata/plog/plogotlp/generated_exportresponse.go b/pdata/plog/plogotlp/generated_exportresponse.go new file mode 100644 index 00000000000..09e0a6e411e --- /dev/null +++ b/pdata/plog/plogotlp/generated_exportresponse.go @@ -0,0 +1,61 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package plogotlp + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" +) + +// ExportResponse represents the response for gRPC/HTTP client/server. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewExportResponse function to create new instances. +// Important: zero-initialized instance is not valid for use. +type ExportResponse struct { + orig *otlpcollectorlog.ExportLogsServiceResponse + state *internal.State +} + +func newExportResponse(orig *otlpcollectorlog.ExportLogsServiceResponse, state *internal.State) ExportResponse { + return ExportResponse{orig: orig, state: state} +} + +// NewExportResponse creates a new empty ExportResponse. +// +// This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice, +// OR directly access the member if this is embedded in another struct. +func NewExportResponse() ExportResponse { + state := internal.StateMutable + return newExportResponse(&otlpcollectorlog.ExportLogsServiceResponse{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms ExportResponse) MoveTo(dest ExportResponse) { + ms.state.AssertMutable() + dest.state.AssertMutable() + // If they point to the same data, they are the same, nothing to do. + if ms.orig == dest.orig { + return + } + *dest.orig = *ms.orig + *ms.orig = otlpcollectorlog.ExportLogsServiceResponse{} +} + +// PartialSuccess returns the partialsuccess associated with this ExportResponse. +func (ms ExportResponse) PartialSuccess() ExportPartialSuccess { + return newExportPartialSuccess(&ms.orig.PartialSuccess, ms.state) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms ExportResponse) CopyTo(dest ExportResponse) { + dest.state.AssertMutable() + internal.CopyOrigExportLogsServiceResponse(dest.orig, ms.orig) +} diff --git a/pdata/plog/plogotlp/generated_exportresponse_test.go b/pdata/plog/plogotlp/generated_exportresponse_test.go new file mode 100644 index 00000000000..a551dc528fa --- /dev/null +++ b/pdata/plog/plogotlp/generated_exportresponse_test.go @@ -0,0 +1,54 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package plogotlp + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" +) + +func TestExportResponse_MoveTo(t *testing.T) { + ms := generateTestExportResponse() + dest := NewExportResponse() + ms.MoveTo(dest) + assert.Equal(t, NewExportResponse(), ms) + assert.Equal(t, generateTestExportResponse(), dest) + dest.MoveTo(dest) + assert.Equal(t, generateTestExportResponse(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newExportResponse(&otlpcollectorlog.ExportLogsServiceResponse{}, &sharedState)) }) + assert.Panics(t, func() { newExportResponse(&otlpcollectorlog.ExportLogsServiceResponse{}, &sharedState).MoveTo(dest) }) +} + +func TestExportResponse_CopyTo(t *testing.T) { + ms := NewExportResponse() + orig := NewExportResponse() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestExportResponse() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newExportResponse(&otlpcollectorlog.ExportLogsServiceResponse{}, &sharedState)) }) +} + +func TestExportResponse_PartialSuccess(t *testing.T) { + ms := NewExportResponse() + assert.Equal(t, NewExportPartialSuccess(), ms.PartialSuccess()) + internal.FillOrigTestExportLogsPartialSuccess(&ms.orig.PartialSuccess) + assert.Equal(t, generateTestExportPartialSuccess(), ms.PartialSuccess()) +} + +func generateTestExportResponse() ExportResponse { + ms := NewExportResponse() + internal.FillOrigTestExportLogsServiceResponse(ms.orig) + return ms +} diff --git a/pdata/plog/plogotlp/response.go b/pdata/plog/plogotlp/response.go index ef3855faed8..1bc83c354db 100644 --- a/pdata/plog/plogotlp/response.go +++ b/pdata/plog/plogotlp/response.go @@ -7,25 +7,9 @@ import ( "slices" "go.opentelemetry.io/collector/pdata/internal" - otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" "go.opentelemetry.io/collector/pdata/internal/json" ) -// ExportResponse represents the response for gRPC/HTTP client/server. -type ExportResponse struct { - orig *otlpcollectorlog.ExportLogsServiceResponse - state *internal.State -} - -// NewExportResponse returns an empty ExportResponse. -func NewExportResponse() ExportResponse { - state := internal.StateMutable - return ExportResponse{ - orig: &otlpcollectorlog.ExportLogsServiceResponse{}, - state: &state, - } -} - // MarshalProto marshals ExportResponse into proto bytes. func (ms ExportResponse) MarshalProto() ([]byte, error) { return ms.orig.Marshal() @@ -40,10 +24,7 @@ func (ms ExportResponse) UnmarshalProto(data []byte) error { func (ms ExportResponse) MarshalJSON() ([]byte, error) { dest := json.BorrowStream(nil) defer json.ReturnStream(dest) - dest.WriteObjectStart() - dest.WriteObjectField("partialSuccess") - internal.MarshalJSONOrigExportLogsPartialSuccess(&ms.orig.PartialSuccess, dest) - dest.WriteObjectEnd() + internal.MarshalJSONOrigExportLogsServiceResponse(ms.orig, dest) return slices.Clone(dest.Buffer()), dest.Error() } @@ -51,23 +32,6 @@ func (ms ExportResponse) MarshalJSON() ([]byte, error) { func (ms ExportResponse) UnmarshalJSON(data []byte) error { iter := json.BorrowIterator(data) defer json.ReturnIterator(iter) - ms.unmarshalJSONIter(iter) + internal.UnmarshalJSONOrigExportLogsServiceResponse(ms.orig, iter) return iter.Error() } - -// PartialSuccess returns the ExportPartialSuccess associated with this ExportResponse. -func (ms ExportResponse) PartialSuccess() ExportPartialSuccess { - return newExportPartialSuccess(&ms.orig.PartialSuccess, ms.state) -} - -func (ms ExportResponse) unmarshalJSONIter(iter *json.Iterator) { - iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { - switch f { - case "partial_success", "partialSuccess": - internal.UnmarshalJSONOrigExportLogsPartialSuccess(&ms.orig.PartialSuccess, iter) - default: - iter.Skip() - } - return true - }) -} diff --git a/pdata/pmetric/generated_metrics.go b/pdata/pmetric/generated_metrics.go new file mode 100644 index 00000000000..0c1c41a5ef8 --- /dev/null +++ b/pdata/pmetric/generated_metrics.go @@ -0,0 +1,67 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pmetric + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" +) + +// Metrics is the top-level struct that is propagated through the metrics pipeline. +// Use NewMetrics to create new instance, zero-initialized instance is not valid for use. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewMetrics function to create new instances. +// Important: zero-initialized instance is not valid for use. +type Metrics internal.Metrics + +func newMetrics(orig *otlpcollectormetrics.ExportMetricsServiceRequest, state *internal.State) Metrics { + return Metrics(internal.NewMetrics(orig, state)) +} + +// NewMetrics creates a new empty Metrics. +// +// This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice, +// OR directly access the member if this is embedded in another struct. +func NewMetrics() Metrics { + state := internal.StateMutable + return newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms Metrics) MoveTo(dest Metrics) { + ms.getState().AssertMutable() + dest.getState().AssertMutable() + // If they point to the same data, they are the same, nothing to do. + if ms.getOrig() == dest.getOrig() { + return + } + *dest.getOrig() = *ms.getOrig() + *ms.getOrig() = otlpcollectormetrics.ExportMetricsServiceRequest{} +} + +// ResourceMetrics returns the ResourceMetrics associated with this Metrics. +func (ms Metrics) ResourceMetrics() ResourceMetricsSlice { + return newResourceMetricsSlice(&ms.getOrig().ResourceMetrics, ms.getState()) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms Metrics) CopyTo(dest Metrics) { + dest.getState().AssertMutable() + internal.CopyOrigExportMetricsServiceRequest(dest.getOrig(), ms.getOrig()) +} + +func (ms Metrics) getOrig() *otlpcollectormetrics.ExportMetricsServiceRequest { + return internal.GetOrigMetrics(internal.Metrics(ms)) +} + +func (ms Metrics) getState() *internal.State { + return internal.GetMetricsState(internal.Metrics(ms)) +} diff --git a/pdata/pmetric/generated_metrics_test.go b/pdata/pmetric/generated_metrics_test.go new file mode 100644 index 00000000000..c24e8a7c6eb --- /dev/null +++ b/pdata/pmetric/generated_metrics_test.go @@ -0,0 +1,52 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pmetric + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" +) + +func TestMetrics_MoveTo(t *testing.T) { + ms := generateTestMetrics() + dest := NewMetrics() + ms.MoveTo(dest) + assert.Equal(t, NewMetrics(), ms) + assert.Equal(t, generateTestMetrics(), dest) + dest.MoveTo(dest) + assert.Equal(t, generateTestMetrics(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{}, &sharedState)) }) + assert.Panics(t, func() { newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{}, &sharedState).MoveTo(dest) }) +} + +func TestMetrics_CopyTo(t *testing.T) { + ms := NewMetrics() + orig := NewMetrics() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestMetrics() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{}, &sharedState)) }) +} + +func TestMetrics_ResourceMetrics(t *testing.T) { + ms := NewMetrics() + assert.Equal(t, NewResourceMetricsSlice(), ms.ResourceMetrics()) + ms.getOrig().ResourceMetrics = internal.GenerateOrigTestResourceMetricsSlice() + assert.Equal(t, generateTestResourceMetricsSlice(), ms.ResourceMetrics()) +} + +func generateTestMetrics() Metrics { + return Metrics(internal.GenerateTestMetrics()) +} diff --git a/pdata/pmetric/json.go b/pdata/pmetric/json.go index 61113180c20..48913985974 100644 --- a/pdata/pmetric/json.go +++ b/pdata/pmetric/json.go @@ -6,6 +6,7 @@ package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" import ( "slices" + "go.opentelemetry.io/collector/pdata/internal" "go.opentelemetry.io/collector/pdata/internal/json" "go.opentelemetry.io/collector/pdata/internal/otlp" ) @@ -19,7 +20,7 @@ type JSONMarshaler struct{} func (*JSONMarshaler) MarshalMetrics(md Metrics) ([]byte, error) { dest := json.BorrowStream(nil) defer json.ReturnStream(dest) - md.marshalJSONStream(dest) + internal.MarshalJSONOrigExportMetricsServiceRequest(md.getOrig(), dest) if dest.Error() != nil { return nil, dest.Error() } @@ -34,7 +35,7 @@ func (*JSONUnmarshaler) UnmarshalMetrics(buf []byte) (Metrics, error) { iter := json.BorrowIterator(buf) defer json.ReturnIterator(iter) md := NewMetrics() - md.unmarshalJSONIter(iter) + internal.UnmarshalJSONOrigExportMetricsServiceRequest(md.getOrig(), iter) if iter.Error() != nil { return Metrics{}, iter.Error() } diff --git a/pdata/pmetric/metrics.go b/pdata/pmetric/metrics.go index f720429f6e4..2d85f0d7158 100644 --- a/pdata/pmetric/metrics.go +++ b/pdata/pmetric/metrics.go @@ -5,47 +5,13 @@ package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" import ( "go.opentelemetry.io/collector/pdata/internal" - otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" - "go.opentelemetry.io/collector/pdata/internal/json" ) -// Metrics is the top-level struct that is propagated through the metrics pipeline. -// Use NewMetrics to create new instance, zero-initialized instance is not valid for use. -type Metrics internal.Metrics - -func newMetrics(orig *otlpcollectormetrics.ExportMetricsServiceRequest) Metrics { - state := internal.StateMutable - return Metrics(internal.NewMetrics(orig, &state)) -} - -func (ms Metrics) getOrig() *otlpcollectormetrics.ExportMetricsServiceRequest { - return internal.GetOrigMetrics(internal.Metrics(ms)) -} - -func (ms Metrics) getState() *internal.State { - return internal.GetMetricsState(internal.Metrics(ms)) -} - -// NewMetrics creates a new Metrics struct. -func NewMetrics() Metrics { - return newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{}) -} - // IsReadOnly returns true if this Metrics instance is read-only. func (ms Metrics) IsReadOnly() bool { return *ms.getState() == internal.StateReadOnly } -// CopyTo copies the Metrics instance overriding the destination. -func (ms Metrics) CopyTo(dest Metrics) { - ms.ResourceMetrics().CopyTo(dest.ResourceMetrics()) -} - -// ResourceMetrics returns the ResourceMetricsSlice associated with this Metrics. -func (ms Metrics) ResourceMetrics() ResourceMetricsSlice { - return newResourceMetricsSlice(&ms.getOrig().ResourceMetrics, internal.GetMetricsState(internal.Metrics(ms))) -} - // MetricCount calculates the total number of metrics. func (ms Metrics) MetricCount() int { metricCount := 0 @@ -94,24 +60,3 @@ func (ms Metrics) DataPointCount() (dataPointCount int) { func (ms Metrics) MarkReadOnly() { internal.SetMetricsState(internal.Metrics(ms), internal.StateReadOnly) } - -func (ms Metrics) marshalJSONStream(dest *json.Stream) { - dest.WriteObjectStart() - if len(ms.getOrig().ResourceMetrics) > 0 { - dest.WriteObjectField("resourceMetrics") - internal.MarshalJSONOrigResourceMetricsSlice(ms.getOrig().ResourceMetrics, dest) - } - dest.WriteObjectEnd() -} - -func (ms Metrics) unmarshalJSONIter(iter *json.Iterator) { - iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { - switch f { - case "resource_metrics", "resourceMetrics": - ms.getOrig().ResourceMetrics = internal.UnmarshalJSONOrigResourceMetricsSlice(iter) - default: - iter.Skip() - } - return true - }) -} diff --git a/pdata/pmetric/metrics_test.go b/pdata/pmetric/metrics_test.go index 063589b39ff..d5131995199 100644 --- a/pdata/pmetric/metrics_test.go +++ b/pdata/pmetric/metrics_test.go @@ -197,7 +197,7 @@ func TestOtlpToInternalReadOnly(t *testing.T) { }, }, }, - }) + }, new(internal.State)) resourceMetrics := md.ResourceMetrics() assert.Equal(t, 1, resourceMetrics.Len()) @@ -285,7 +285,7 @@ func TestOtlpToFromInternalReadOnly(t *testing.T) { }, }, }, - }) + }, new(internal.State)) // Test that nothing changed assert.EqualValues(t, &otlpmetrics.MetricsData{ ResourceMetrics: []*otlpmetrics.ResourceMetrics{ @@ -317,7 +317,7 @@ func TestOtlpToFromInternalGaugeMutating(t *testing.T) { }, }, }, - }) + }, new(internal.State)) resourceMetrics := md.ResourceMetrics() metric := resourceMetrics.At(0).ScopeMetrics().At(0).Metrics().At(0) // Mutate MetricDescriptor @@ -399,7 +399,7 @@ func TestOtlpToFromInternalSumMutating(t *testing.T) { }, }, }, - }) + }, new(internal.State)) resourceMetrics := md.ResourceMetrics() metric := resourceMetrics.At(0).ScopeMetrics().At(0).Metrics().At(0) // Mutate MetricDescriptor @@ -483,7 +483,7 @@ func TestOtlpToFromInternalHistogramMutating(t *testing.T) { }, }, }, - }) + }, new(internal.State)) resourceMetrics := md.ResourceMetrics() metric := resourceMetrics.At(0).ScopeMetrics().At(0).Metrics().At(0) // Mutate MetricDescriptor @@ -566,7 +566,7 @@ func TestOtlpToFromInternalExponentialHistogramMutating(t *testing.T) { }, }, }, - }) + }, new(internal.State)) resourceMetrics := md.ResourceMetrics() metric := resourceMetrics.At(0).ScopeMetrics().At(0).Metrics().At(0) // Mutate MetricDescriptor @@ -660,10 +660,11 @@ func BenchmarkOtlpToFromInternal_PassThrough(b *testing.B) { }, }, } + var state internal.State b.ResetTimer() for n := 0; n < b.N; n++ { - md := newMetrics(req) + md := newMetrics(req, &state) newReq := md.getOrig() if len(req.ResourceMetrics) != len(newReq.ResourceMetrics) { b.Fail() @@ -685,10 +686,11 @@ func BenchmarkOtlpToFromInternal_Gauge_MutateOneLabel(b *testing.B) { }, }, } + var state internal.State b.ResetTimer() for n := 0; n < b.N; n++ { - md := newMetrics(req) + md := newMetrics(req, &state) md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0).Gauge().DataPoints().At(0).Attributes(). PutStr("key0", "value2") newReq := md.getOrig() @@ -712,10 +714,11 @@ func BenchmarkOtlpToFromInternal_Sum_MutateOneLabel(b *testing.B) { }, }, } + var state internal.State b.ResetTimer() for n := 0; n < b.N; n++ { - md := newMetrics(req) + md := newMetrics(req, &state) md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0).Sum().DataPoints().At(0).Attributes(). PutStr("key0", "value2") newReq := md.getOrig() @@ -739,10 +742,11 @@ func BenchmarkOtlpToFromInternal_HistogramPoints_MutateOneLabel(b *testing.B) { }, }, } + var state internal.State b.ResetTimer() for n := 0; n < b.N; n++ { - md := newMetrics(req) + md := newMetrics(req, &state) md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0).Histogram().DataPoints().At(0).Attributes(). PutStr("key0", "value2") newReq := md.getOrig() @@ -893,7 +897,7 @@ func generateTestProtoHistogramMetric() *otlpmetrics.Metric { func generateMetricsEmptyResource() Metrics { return newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{ ResourceMetrics: []*otlpmetrics.ResourceMetrics{{}}, - }) + }, new(internal.State)) } func generateMetricsEmptyInstrumentation() Metrics { @@ -903,7 +907,7 @@ func generateMetricsEmptyInstrumentation() Metrics { ScopeMetrics: []*otlpmetrics.ScopeMetrics{{}}, }, }, - }) + }, new(internal.State)) } func generateMetricsEmptyMetrics() Metrics { @@ -917,7 +921,7 @@ func generateMetricsEmptyMetrics() Metrics { }, }, }, - }) + }, new(internal.State)) } func generateMetricsEmptyDataPoints() Metrics { @@ -941,7 +945,7 @@ func generateMetricsEmptyDataPoints() Metrics { }, }, }, - }) + }, new(internal.State)) } func BenchmarkMetricsUsage(b *testing.B) { @@ -1009,9 +1013,3 @@ func BenchmarkMetricsMarshalJSON(b *testing.B) { require.NotNil(b, jsonBuf) } } - -func generateTestMetrics() Metrics { - md := NewMetrics() - md.getOrig().ResourceMetrics = internal.GenerateOrigTestResourceMetricsSlice() - return md -} diff --git a/pdata/pmetric/pmetricotlp/generated_exportresponse.go b/pdata/pmetric/pmetricotlp/generated_exportresponse.go new file mode 100644 index 00000000000..32beed82a8d --- /dev/null +++ b/pdata/pmetric/pmetricotlp/generated_exportresponse.go @@ -0,0 +1,61 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pmetricotlp + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" +) + +// ExportResponse represents the response for gRPC/HTTP client/server. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewExportResponse function to create new instances. +// Important: zero-initialized instance is not valid for use. +type ExportResponse struct { + orig *otlpcollectormetrics.ExportMetricsServiceResponse + state *internal.State +} + +func newExportResponse(orig *otlpcollectormetrics.ExportMetricsServiceResponse, state *internal.State) ExportResponse { + return ExportResponse{orig: orig, state: state} +} + +// NewExportResponse creates a new empty ExportResponse. +// +// This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice, +// OR directly access the member if this is embedded in another struct. +func NewExportResponse() ExportResponse { + state := internal.StateMutable + return newExportResponse(&otlpcollectormetrics.ExportMetricsServiceResponse{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms ExportResponse) MoveTo(dest ExportResponse) { + ms.state.AssertMutable() + dest.state.AssertMutable() + // If they point to the same data, they are the same, nothing to do. + if ms.orig == dest.orig { + return + } + *dest.orig = *ms.orig + *ms.orig = otlpcollectormetrics.ExportMetricsServiceResponse{} +} + +// PartialSuccess returns the partialsuccess associated with this ExportResponse. +func (ms ExportResponse) PartialSuccess() ExportPartialSuccess { + return newExportPartialSuccess(&ms.orig.PartialSuccess, ms.state) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms ExportResponse) CopyTo(dest ExportResponse) { + dest.state.AssertMutable() + internal.CopyOrigExportMetricsServiceResponse(dest.orig, ms.orig) +} diff --git a/pdata/pmetric/pmetricotlp/generated_exportresponse_test.go b/pdata/pmetric/pmetricotlp/generated_exportresponse_test.go new file mode 100644 index 00000000000..3bd50bc6471 --- /dev/null +++ b/pdata/pmetric/pmetricotlp/generated_exportresponse_test.go @@ -0,0 +1,60 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pmetricotlp + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" +) + +func TestExportResponse_MoveTo(t *testing.T) { + ms := generateTestExportResponse() + dest := NewExportResponse() + ms.MoveTo(dest) + assert.Equal(t, NewExportResponse(), ms) + assert.Equal(t, generateTestExportResponse(), dest) + dest.MoveTo(dest) + assert.Equal(t, generateTestExportResponse(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + ms.MoveTo(newExportResponse(&otlpcollectormetrics.ExportMetricsServiceResponse{}, &sharedState)) + }) + assert.Panics(t, func() { + newExportResponse(&otlpcollectormetrics.ExportMetricsServiceResponse{}, &sharedState).MoveTo(dest) + }) +} + +func TestExportResponse_CopyTo(t *testing.T) { + ms := NewExportResponse() + orig := NewExportResponse() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestExportResponse() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + ms.CopyTo(newExportResponse(&otlpcollectormetrics.ExportMetricsServiceResponse{}, &sharedState)) + }) +} + +func TestExportResponse_PartialSuccess(t *testing.T) { + ms := NewExportResponse() + assert.Equal(t, NewExportPartialSuccess(), ms.PartialSuccess()) + internal.FillOrigTestExportMetricsPartialSuccess(&ms.orig.PartialSuccess) + assert.Equal(t, generateTestExportPartialSuccess(), ms.PartialSuccess()) +} + +func generateTestExportResponse() ExportResponse { + ms := NewExportResponse() + internal.FillOrigTestExportMetricsServiceResponse(ms.orig) + return ms +} diff --git a/pdata/pmetric/pmetricotlp/response.go b/pdata/pmetric/pmetricotlp/response.go index f7754504b76..369c6743b0d 100644 --- a/pdata/pmetric/pmetricotlp/response.go +++ b/pdata/pmetric/pmetricotlp/response.go @@ -7,25 +7,9 @@ import ( "slices" "go.opentelemetry.io/collector/pdata/internal" - otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1" "go.opentelemetry.io/collector/pdata/internal/json" ) -// ExportResponse represents the response for gRPC/HTTP client/server. -type ExportResponse struct { - orig *otlpcollectormetrics.ExportMetricsServiceResponse - state *internal.State -} - -// NewExportResponse returns an empty ExportResponse. -func NewExportResponse() ExportResponse { - state := internal.StateMutable - return ExportResponse{ - orig: &otlpcollectormetrics.ExportMetricsServiceResponse{}, - state: &state, - } -} - // MarshalProto marshals ExportResponse into proto bytes. func (ms ExportResponse) MarshalProto() ([]byte, error) { return ms.orig.Marshal() @@ -40,10 +24,7 @@ func (ms ExportResponse) UnmarshalProto(data []byte) error { func (ms ExportResponse) MarshalJSON() ([]byte, error) { dest := json.BorrowStream(nil) defer json.ReturnStream(dest) - dest.WriteObjectStart() - dest.WriteObjectField("partialSuccess") - internal.MarshalJSONOrigExportMetricsPartialSuccess(&ms.orig.PartialSuccess, dest) - dest.WriteObjectEnd() + internal.MarshalJSONOrigExportMetricsServiceResponse(ms.orig, dest) return slices.Clone(dest.Buffer()), dest.Error() } @@ -51,23 +32,6 @@ func (ms ExportResponse) MarshalJSON() ([]byte, error) { func (ms ExportResponse) UnmarshalJSON(data []byte) error { iter := json.BorrowIterator(data) defer json.ReturnIterator(iter) - ms.unmarshalJSONIter(iter) + internal.UnmarshalJSONOrigExportMetricsServiceResponse(ms.orig, iter) return iter.Error() } - -// PartialSuccess returns the ExportLogsPartialSuccess associated with this ExportResponse. -func (ms ExportResponse) PartialSuccess() ExportPartialSuccess { - return newExportPartialSuccess(&ms.orig.PartialSuccess, ms.state) -} - -func (ms ExportResponse) unmarshalJSONIter(iter *json.Iterator) { - iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { - switch f { - case "partial_success", "partialSuccess": - internal.UnmarshalJSONOrigExportMetricsPartialSuccess(&ms.orig.PartialSuccess, iter) - default: - iter.Skip() - } - return true - }) -} diff --git a/pdata/pprofile/generated_profiles.go b/pdata/pprofile/generated_profiles.go new file mode 100644 index 00000000000..bce07dee478 --- /dev/null +++ b/pdata/pprofile/generated_profiles.go @@ -0,0 +1,72 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pprofile + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" +) + +// Profiles is the top-level struct that is propagated through the profiles pipeline. +// Use NewProfiles to create new instance, zero-initialized instance is not valid for use. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewProfiles function to create new instances. +// Important: zero-initialized instance is not valid for use. +type Profiles internal.Profiles + +func newProfiles(orig *otlpcollectorprofile.ExportProfilesServiceRequest, state *internal.State) Profiles { + return Profiles(internal.NewProfiles(orig, state)) +} + +// NewProfiles creates a new empty Profiles. +// +// This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice, +// OR directly access the member if this is embedded in another struct. +func NewProfiles() Profiles { + state := internal.StateMutable + return newProfiles(&otlpcollectorprofile.ExportProfilesServiceRequest{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms Profiles) MoveTo(dest Profiles) { + ms.getState().AssertMutable() + dest.getState().AssertMutable() + // If they point to the same data, they are the same, nothing to do. + if ms.getOrig() == dest.getOrig() { + return + } + *dest.getOrig() = *ms.getOrig() + *ms.getOrig() = otlpcollectorprofile.ExportProfilesServiceRequest{} +} + +// ResourceProfiles returns the ResourceProfiles associated with this Profiles. +func (ms Profiles) ResourceProfiles() ResourceProfilesSlice { + return newResourceProfilesSlice(&ms.getOrig().ResourceProfiles, ms.getState()) +} + +// ProfilesDictionary returns the profilesdictionary associated with this Profiles. +func (ms Profiles) ProfilesDictionary() ProfilesDictionary { + return newProfilesDictionary(&ms.getOrig().Dictionary, ms.getState()) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms Profiles) CopyTo(dest Profiles) { + dest.getState().AssertMutable() + internal.CopyOrigExportProfilesServiceRequest(dest.getOrig(), ms.getOrig()) +} + +func (ms Profiles) getOrig() *otlpcollectorprofile.ExportProfilesServiceRequest { + return internal.GetOrigProfiles(internal.Profiles(ms)) +} + +func (ms Profiles) getState() *internal.State { + return internal.GetProfilesState(internal.Profiles(ms)) +} diff --git a/pdata/pprofile/generated_profiles_test.go b/pdata/pprofile/generated_profiles_test.go new file mode 100644 index 00000000000..8964bb35dd8 --- /dev/null +++ b/pdata/pprofile/generated_profiles_test.go @@ -0,0 +1,59 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pprofile + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" +) + +func TestProfiles_MoveTo(t *testing.T) { + ms := generateTestProfiles() + dest := NewProfiles() + ms.MoveTo(dest) + assert.Equal(t, NewProfiles(), ms) + assert.Equal(t, generateTestProfiles(), dest) + dest.MoveTo(dest) + assert.Equal(t, generateTestProfiles(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newProfiles(&otlpcollectorprofile.ExportProfilesServiceRequest{}, &sharedState)) }) + assert.Panics(t, func() { newProfiles(&otlpcollectorprofile.ExportProfilesServiceRequest{}, &sharedState).MoveTo(dest) }) +} + +func TestProfiles_CopyTo(t *testing.T) { + ms := NewProfiles() + orig := NewProfiles() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestProfiles() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newProfiles(&otlpcollectorprofile.ExportProfilesServiceRequest{}, &sharedState)) }) +} + +func TestProfiles_ResourceProfiles(t *testing.T) { + ms := NewProfiles() + assert.Equal(t, NewResourceProfilesSlice(), ms.ResourceProfiles()) + ms.getOrig().ResourceProfiles = internal.GenerateOrigTestResourceProfilesSlice() + assert.Equal(t, generateTestResourceProfilesSlice(), ms.ResourceProfiles()) +} + +func TestProfiles_ProfilesDictionary(t *testing.T) { + ms := NewProfiles() + assert.Equal(t, NewProfilesDictionary(), ms.ProfilesDictionary()) + internal.FillOrigTestProfilesDictionary(&ms.getOrig().Dictionary) + assert.Equal(t, generateTestProfilesDictionary(), ms.ProfilesDictionary()) +} + +func generateTestProfiles() Profiles { + return Profiles(internal.GenerateTestProfiles()) +} diff --git a/pdata/pprofile/json.go b/pdata/pprofile/json.go index bfb66e2ce61..25ed17bfd90 100644 --- a/pdata/pprofile/json.go +++ b/pdata/pprofile/json.go @@ -6,6 +6,7 @@ package pprofile // import "go.opentelemetry.io/collector/pdata/pprofile" import ( "slices" + "go.opentelemetry.io/collector/pdata/internal" "go.opentelemetry.io/collector/pdata/internal/json" "go.opentelemetry.io/collector/pdata/internal/otlp" ) @@ -17,7 +18,7 @@ type JSONMarshaler struct{} func (*JSONMarshaler) MarshalProfiles(pd Profiles) ([]byte, error) { dest := json.BorrowStream(nil) defer json.ReturnStream(dest) - pd.marshalJSONStream(dest) + internal.MarshalJSONOrigExportProfilesServiceRequest(pd.getOrig(), dest) if dest.Error() != nil { return nil, dest.Error() } @@ -31,11 +32,11 @@ type JSONUnmarshaler struct{} func (*JSONUnmarshaler) UnmarshalProfiles(buf []byte) (Profiles, error) { iter := json.BorrowIterator(buf) defer json.ReturnIterator(iter) - td := NewProfiles() - td.unmarshalJSONIter(iter) + pd := NewProfiles() + internal.UnmarshalJSONOrigExportProfilesServiceRequest(pd.getOrig(), iter) if iter.Error() != nil { return Profiles{}, iter.Error() } - otlp.MigrateProfiles(td.getOrig().ResourceProfiles) - return td, nil + otlp.MigrateProfiles(pd.getOrig().ResourceProfiles) + return pd, nil } diff --git a/pdata/pprofile/pprofileotlp/generated_exportresponse.go b/pdata/pprofile/pprofileotlp/generated_exportresponse.go new file mode 100644 index 00000000000..90068766864 --- /dev/null +++ b/pdata/pprofile/pprofileotlp/generated_exportresponse.go @@ -0,0 +1,61 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pprofileotlp + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" +) + +// ExportResponse represents the response for gRPC/HTTP client/server. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewExportResponse function to create new instances. +// Important: zero-initialized instance is not valid for use. +type ExportResponse struct { + orig *otlpcollectorprofile.ExportProfilesServiceResponse + state *internal.State +} + +func newExportResponse(orig *otlpcollectorprofile.ExportProfilesServiceResponse, state *internal.State) ExportResponse { + return ExportResponse{orig: orig, state: state} +} + +// NewExportResponse creates a new empty ExportResponse. +// +// This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice, +// OR directly access the member if this is embedded in another struct. +func NewExportResponse() ExportResponse { + state := internal.StateMutable + return newExportResponse(&otlpcollectorprofile.ExportProfilesServiceResponse{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms ExportResponse) MoveTo(dest ExportResponse) { + ms.state.AssertMutable() + dest.state.AssertMutable() + // If they point to the same data, they are the same, nothing to do. + if ms.orig == dest.orig { + return + } + *dest.orig = *ms.orig + *ms.orig = otlpcollectorprofile.ExportProfilesServiceResponse{} +} + +// PartialSuccess returns the partialsuccess associated with this ExportResponse. +func (ms ExportResponse) PartialSuccess() ExportPartialSuccess { + return newExportPartialSuccess(&ms.orig.PartialSuccess, ms.state) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms ExportResponse) CopyTo(dest ExportResponse) { + dest.state.AssertMutable() + internal.CopyOrigExportProfilesServiceResponse(dest.orig, ms.orig) +} diff --git a/pdata/pprofile/pprofileotlp/generated_exportresponse_test.go b/pdata/pprofile/pprofileotlp/generated_exportresponse_test.go new file mode 100644 index 00000000000..a2cb1698d15 --- /dev/null +++ b/pdata/pprofile/pprofileotlp/generated_exportresponse_test.go @@ -0,0 +1,60 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pprofileotlp + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" +) + +func TestExportResponse_MoveTo(t *testing.T) { + ms := generateTestExportResponse() + dest := NewExportResponse() + ms.MoveTo(dest) + assert.Equal(t, NewExportResponse(), ms) + assert.Equal(t, generateTestExportResponse(), dest) + dest.MoveTo(dest) + assert.Equal(t, generateTestExportResponse(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + ms.MoveTo(newExportResponse(&otlpcollectorprofile.ExportProfilesServiceResponse{}, &sharedState)) + }) + assert.Panics(t, func() { + newExportResponse(&otlpcollectorprofile.ExportProfilesServiceResponse{}, &sharedState).MoveTo(dest) + }) +} + +func TestExportResponse_CopyTo(t *testing.T) { + ms := NewExportResponse() + orig := NewExportResponse() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestExportResponse() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + ms.CopyTo(newExportResponse(&otlpcollectorprofile.ExportProfilesServiceResponse{}, &sharedState)) + }) +} + +func TestExportResponse_PartialSuccess(t *testing.T) { + ms := NewExportResponse() + assert.Equal(t, NewExportPartialSuccess(), ms.PartialSuccess()) + internal.FillOrigTestExportProfilesPartialSuccess(&ms.orig.PartialSuccess) + assert.Equal(t, generateTestExportPartialSuccess(), ms.PartialSuccess()) +} + +func generateTestExportResponse() ExportResponse { + ms := NewExportResponse() + internal.FillOrigTestExportProfilesServiceResponse(ms.orig) + return ms +} diff --git a/pdata/pprofile/pprofileotlp/response.go b/pdata/pprofile/pprofileotlp/response.go index 677e97e510e..64ed98b945b 100644 --- a/pdata/pprofile/pprofileotlp/response.go +++ b/pdata/pprofile/pprofileotlp/response.go @@ -7,25 +7,9 @@ import ( "slices" "go.opentelemetry.io/collector/pdata/internal" - otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" "go.opentelemetry.io/collector/pdata/internal/json" ) -// ExportResponse represents the response for gRPC/HTTP client/server. -type ExportResponse struct { - orig *otlpcollectorprofile.ExportProfilesServiceResponse - state *internal.State -} - -// NewExportResponse returns an empty ExportResponse. -func NewExportResponse() ExportResponse { - state := internal.StateMutable - return ExportResponse{ - orig: &otlpcollectorprofile.ExportProfilesServiceResponse{}, - state: &state, - } -} - // MarshalProto marshals ExportResponse into proto bytes. func (ms ExportResponse) MarshalProto() ([]byte, error) { return ms.orig.Marshal() @@ -40,10 +24,7 @@ func (ms ExportResponse) UnmarshalProto(data []byte) error { func (ms ExportResponse) MarshalJSON() ([]byte, error) { dest := json.BorrowStream(nil) defer json.ReturnStream(dest) - dest.WriteObjectStart() - dest.WriteObjectField("partialSuccess") - internal.MarshalJSONOrigExportProfilesPartialSuccess(&ms.orig.PartialSuccess, dest) - dest.WriteObjectEnd() + internal.MarshalJSONOrigExportProfilesServiceResponse(ms.orig, dest) return slices.Clone(dest.Buffer()), dest.Error() } @@ -51,23 +32,6 @@ func (ms ExportResponse) MarshalJSON() ([]byte, error) { func (ms ExportResponse) UnmarshalJSON(data []byte) error { iter := json.BorrowIterator(data) defer json.ReturnIterator(iter) - ms.unmarshalJSONIter(iter) + internal.UnmarshalJSONOrigExportProfilesServiceResponse(ms.orig, iter) return iter.Error() } - -func (ms ExportResponse) unmarshalJSONIter(iter *json.Iterator) { - iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { - switch f { - case "partial_success", "partialSuccess": - internal.UnmarshalJSONOrigExportProfilesPartialSuccess(&ms.orig.PartialSuccess, iter) - default: - iter.Skip() - } - return true - }) -} - -// PartialSuccess returns the ExportLogsPartialSuccess associated with this ExportResponse. -func (ms ExportResponse) PartialSuccess() ExportPartialSuccess { - return newExportPartialSuccess(&ms.orig.PartialSuccess, ms.state) -} diff --git a/pdata/pprofile/profiles.go b/pdata/pprofile/profiles.go index 92482e2a4c4..a26467f1b97 100644 --- a/pdata/pprofile/profiles.go +++ b/pdata/pprofile/profiles.go @@ -5,30 +5,11 @@ package pprofile // import "go.opentelemetry.io/collector/pdata/pprofile" import ( "go.opentelemetry.io/collector/pdata/internal" - otlpcollectorprofile "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/profiles/v1development" - "go.opentelemetry.io/collector/pdata/internal/json" ) -// Profiles is the top-level struct that is propagated through the profiles pipeline. -// Use NewProfiles to create new instance, zero-initialized instance is not valid for use. -type Profiles internal.Profiles - -func newProfiles(orig *otlpcollectorprofile.ExportProfilesServiceRequest) Profiles { - state := internal.StateMutable - return Profiles(internal.NewProfiles(orig, &state)) -} - -func (ms Profiles) getOrig() *otlpcollectorprofile.ExportProfilesServiceRequest { - return internal.GetOrigProfiles(internal.Profiles(ms)) -} - -func (ms Profiles) getState() *internal.State { - return internal.GetProfilesState(internal.Profiles(ms)) -} - -// NewProfiles creates a new Profiles struct. -func NewProfiles() Profiles { - return newProfiles(&otlpcollectorprofile.ExportProfilesServiceRequest{}) +// MarkReadOnly marks the ResourceProfiles as shared so that no further modifications can be done on it. +func (ms Profiles) MarkReadOnly() { + internal.SetProfilesState(internal.Profiles(ms), internal.StateReadOnly) } // IsReadOnly returns true if this ResourceProfiles instance is read-only. @@ -36,27 +17,6 @@ func (ms Profiles) IsReadOnly() bool { return *ms.getState() == internal.StateReadOnly } -// CopyTo copies the Profiles instance overriding the destination. -func (ms Profiles) CopyTo(dest Profiles) { - ms.ResourceProfiles().CopyTo(dest.ResourceProfiles()) - ms.ProfilesDictionary().CopyTo(dest.ProfilesDictionary()) -} - -// ResourceProfiles returns the ResourceProfilesSlice associated with this Profiles. -func (ms Profiles) ResourceProfiles() ResourceProfilesSlice { - return newResourceProfilesSlice(&ms.getOrig().ResourceProfiles, internal.GetProfilesState(internal.Profiles(ms))) -} - -// ProfilesDictionary returns the ProfilesDictionary associated with this Profiles. -func (ms Profiles) ProfilesDictionary() ProfilesDictionary { - return newProfilesDictionary(&ms.getOrig().Dictionary, internal.GetProfilesState(internal.Profiles(ms))) -} - -// MarkReadOnly marks the ResourceProfiles as shared so that no further modifications can be done on it. -func (ms Profiles) MarkReadOnly() { - internal.SetProfilesState(internal.Profiles(ms), internal.StateReadOnly) -} - // SampleCount calculates the total number of samples. func (ms Profiles) SampleCount() int { sampleCount := 0 @@ -73,29 +33,3 @@ func (ms Profiles) SampleCount() int { } return sampleCount } - -func (ms Profiles) marshalJSONStream(dest *json.Stream) { - dest.WriteObjectStart() - if len(ms.getOrig().ResourceProfiles) > 0 { - dest.WriteObjectField("resourceProfiles") - internal.MarshalJSONOrigResourceProfilesSlice(ms.getOrig().ResourceProfiles, dest) - } - dest.WriteObjectField("dictionary") - internal.MarshalJSONOrigProfilesDictionary(&ms.getOrig().Dictionary, dest) - dest.WriteObjectEnd() -} - -func (ms Profiles) unmarshalJSONIter(iter *json.Iterator) { - iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { - switch f { - case "resourceProfiles", "resource_profiles": - ms.getOrig().ResourceProfiles = internal.UnmarshalJSONOrigResourceProfilesSlice(iter) - case "dictionary": - internal.UnmarshalJSONOrigProfilesDictionary(&ms.getOrig().Dictionary, iter) - return true - default: - iter.Skip() - } - return true - }) -} diff --git a/pdata/pprofile/profiles_test.go b/pdata/pprofile/profiles_test.go index 08c1e238561..a941377d218 100644 --- a/pdata/pprofile/profiles_test.go +++ b/pdata/pprofile/profiles_test.go @@ -66,14 +66,14 @@ func TestSampleCount(t *testing.T) { func TestSampleCountWithEmpty(t *testing.T) { assert.Equal(t, 0, newProfiles(&otlpcollectorprofile.ExportProfilesServiceRequest{ ResourceProfiles: []*otlpprofile.ResourceProfiles{{}}, - }).SampleCount()) + }, new(internal.State)).SampleCount()) assert.Equal(t, 0, newProfiles(&otlpcollectorprofile.ExportProfilesServiceRequest{ ResourceProfiles: []*otlpprofile.ResourceProfiles{ { ScopeProfiles: []*otlpprofile.ScopeProfiles{{}}, }, }, - }).SampleCount()) + }, new(internal.State)).SampleCount()) assert.Equal(t, 1, newProfiles(&otlpcollectorprofile.ExportProfilesServiceRequest{ ResourceProfiles: []*otlpprofile.ResourceProfiles{ { @@ -90,7 +90,7 @@ func TestSampleCountWithEmpty(t *testing.T) { }, }, }, - }).SampleCount()) + }, new(internal.State)).SampleCount()) } func BenchmarkProfilesUsage(b *testing.B) { @@ -151,10 +151,3 @@ func BenchmarkProfilesMarshalJSON(b *testing.B) { require.NotNil(b, jsonBuf) } } - -func generateTestProfiles() Profiles { - pd := NewProfiles() - pd.getOrig().ResourceProfiles = internal.GenerateOrigTestResourceProfilesSlice() - internal.FillOrigTestProfilesDictionary(&pd.getOrig().Dictionary) - return pd -} diff --git a/pdata/ptrace/generated_traces.go b/pdata/ptrace/generated_traces.go new file mode 100644 index 00000000000..9764bd255af --- /dev/null +++ b/pdata/ptrace/generated_traces.go @@ -0,0 +1,67 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package ptrace + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" +) + +// Traces is the top-level struct that is propagated through the traces pipeline. +// Use NewTraces to create new instance, zero-initialized instance is not valid for use. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewTraces function to create new instances. +// Important: zero-initialized instance is not valid for use. +type Traces internal.Traces + +func newTraces(orig *otlpcollectortrace.ExportTraceServiceRequest, state *internal.State) Traces { + return Traces(internal.NewTraces(orig, state)) +} + +// NewTraces creates a new empty Traces. +// +// This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice, +// OR directly access the member if this is embedded in another struct. +func NewTraces() Traces { + state := internal.StateMutable + return newTraces(&otlpcollectortrace.ExportTraceServiceRequest{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms Traces) MoveTo(dest Traces) { + ms.getState().AssertMutable() + dest.getState().AssertMutable() + // If they point to the same data, they are the same, nothing to do. + if ms.getOrig() == dest.getOrig() { + return + } + *dest.getOrig() = *ms.getOrig() + *ms.getOrig() = otlpcollectortrace.ExportTraceServiceRequest{} +} + +// ResourceSpans returns the ResourceSpans associated with this Traces. +func (ms Traces) ResourceSpans() ResourceSpansSlice { + return newResourceSpansSlice(&ms.getOrig().ResourceSpans, ms.getState()) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms Traces) CopyTo(dest Traces) { + dest.getState().AssertMutable() + internal.CopyOrigExportTraceServiceRequest(dest.getOrig(), ms.getOrig()) +} + +func (ms Traces) getOrig() *otlpcollectortrace.ExportTraceServiceRequest { + return internal.GetOrigTraces(internal.Traces(ms)) +} + +func (ms Traces) getState() *internal.State { + return internal.GetTracesState(internal.Traces(ms)) +} diff --git a/pdata/ptrace/generated_traces_test.go b/pdata/ptrace/generated_traces_test.go new file mode 100644 index 00000000000..1806818d2bb --- /dev/null +++ b/pdata/ptrace/generated_traces_test.go @@ -0,0 +1,52 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package ptrace + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" +) + +func TestTraces_MoveTo(t *testing.T) { + ms := generateTestTraces() + dest := NewTraces() + ms.MoveTo(dest) + assert.Equal(t, NewTraces(), ms) + assert.Equal(t, generateTestTraces(), dest) + dest.MoveTo(dest) + assert.Equal(t, generateTestTraces(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newTraces(&otlpcollectortrace.ExportTraceServiceRequest{}, &sharedState)) }) + assert.Panics(t, func() { newTraces(&otlpcollectortrace.ExportTraceServiceRequest{}, &sharedState).MoveTo(dest) }) +} + +func TestTraces_CopyTo(t *testing.T) { + ms := NewTraces() + orig := NewTraces() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestTraces() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newTraces(&otlpcollectortrace.ExportTraceServiceRequest{}, &sharedState)) }) +} + +func TestTraces_ResourceSpans(t *testing.T) { + ms := NewTraces() + assert.Equal(t, NewResourceSpansSlice(), ms.ResourceSpans()) + ms.getOrig().ResourceSpans = internal.GenerateOrigTestResourceSpansSlice() + assert.Equal(t, generateTestResourceSpansSlice(), ms.ResourceSpans()) +} + +func generateTestTraces() Traces { + return Traces(internal.GenerateTestTraces()) +} diff --git a/pdata/ptrace/json.go b/pdata/ptrace/json.go index 94cd6328a90..1c1cab317dd 100644 --- a/pdata/ptrace/json.go +++ b/pdata/ptrace/json.go @@ -6,6 +6,7 @@ package ptrace // import "go.opentelemetry.io/collector/pdata/ptrace" import ( "slices" + "go.opentelemetry.io/collector/pdata/internal" "go.opentelemetry.io/collector/pdata/internal/json" "go.opentelemetry.io/collector/pdata/internal/otlp" ) @@ -17,7 +18,7 @@ type JSONMarshaler struct{} func (*JSONMarshaler) MarshalTraces(td Traces) ([]byte, error) { dest := json.BorrowStream(nil) defer json.ReturnStream(dest) - td.marshalJSONStream(dest) + internal.MarshalJSONOrigExportTraceServiceRequest(td.getOrig(), dest) if dest.Error() != nil { return nil, dest.Error() } @@ -32,7 +33,7 @@ func (*JSONUnmarshaler) UnmarshalTraces(buf []byte) (Traces, error) { iter := json.BorrowIterator(buf) defer json.ReturnIterator(iter) td := NewTraces() - td.unmarshalJSONIter(iter) + internal.UnmarshalJSONOrigExportTraceServiceRequest(td.getOrig(), iter) if iter.Error() != nil { return Traces{}, iter.Error() } diff --git a/pdata/ptrace/ptraceotlp/generated_exportresponse.go b/pdata/ptrace/ptraceotlp/generated_exportresponse.go new file mode 100644 index 00000000000..131e8041909 --- /dev/null +++ b/pdata/ptrace/ptraceotlp/generated_exportresponse.go @@ -0,0 +1,61 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package ptraceotlp + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" +) + +// ExportResponse represents the response for gRPC/HTTP client/server. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewExportResponse function to create new instances. +// Important: zero-initialized instance is not valid for use. +type ExportResponse struct { + orig *otlpcollectortrace.ExportTraceServiceResponse + state *internal.State +} + +func newExportResponse(orig *otlpcollectortrace.ExportTraceServiceResponse, state *internal.State) ExportResponse { + return ExportResponse{orig: orig, state: state} +} + +// NewExportResponse creates a new empty ExportResponse. +// +// This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice, +// OR directly access the member if this is embedded in another struct. +func NewExportResponse() ExportResponse { + state := internal.StateMutable + return newExportResponse(&otlpcollectortrace.ExportTraceServiceResponse{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms ExportResponse) MoveTo(dest ExportResponse) { + ms.state.AssertMutable() + dest.state.AssertMutable() + // If they point to the same data, they are the same, nothing to do. + if ms.orig == dest.orig { + return + } + *dest.orig = *ms.orig + *ms.orig = otlpcollectortrace.ExportTraceServiceResponse{} +} + +// PartialSuccess returns the partialsuccess associated with this ExportResponse. +func (ms ExportResponse) PartialSuccess() ExportPartialSuccess { + return newExportPartialSuccess(&ms.orig.PartialSuccess, ms.state) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms ExportResponse) CopyTo(dest ExportResponse) { + dest.state.AssertMutable() + internal.CopyOrigExportTraceServiceResponse(dest.orig, ms.orig) +} diff --git a/pdata/ptrace/ptraceotlp/generated_exportresponse_test.go b/pdata/ptrace/ptraceotlp/generated_exportresponse_test.go new file mode 100644 index 00000000000..d9492ccd804 --- /dev/null +++ b/pdata/ptrace/ptraceotlp/generated_exportresponse_test.go @@ -0,0 +1,54 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package ptraceotlp + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" +) + +func TestExportResponse_MoveTo(t *testing.T) { + ms := generateTestExportResponse() + dest := NewExportResponse() + ms.MoveTo(dest) + assert.Equal(t, NewExportResponse(), ms) + assert.Equal(t, generateTestExportResponse(), dest) + dest.MoveTo(dest) + assert.Equal(t, generateTestExportResponse(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newExportResponse(&otlpcollectortrace.ExportTraceServiceResponse{}, &sharedState)) }) + assert.Panics(t, func() { newExportResponse(&otlpcollectortrace.ExportTraceServiceResponse{}, &sharedState).MoveTo(dest) }) +} + +func TestExportResponse_CopyTo(t *testing.T) { + ms := NewExportResponse() + orig := NewExportResponse() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestExportResponse() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newExportResponse(&otlpcollectortrace.ExportTraceServiceResponse{}, &sharedState)) }) +} + +func TestExportResponse_PartialSuccess(t *testing.T) { + ms := NewExportResponse() + assert.Equal(t, NewExportPartialSuccess(), ms.PartialSuccess()) + internal.FillOrigTestExportTracePartialSuccess(&ms.orig.PartialSuccess) + assert.Equal(t, generateTestExportPartialSuccess(), ms.PartialSuccess()) +} + +func generateTestExportResponse() ExportResponse { + ms := NewExportResponse() + internal.FillOrigTestExportTraceServiceResponse(ms.orig) + return ms +} diff --git a/pdata/ptrace/ptraceotlp/response.go b/pdata/ptrace/ptraceotlp/response.go index d2296c4de2a..14165eefeb1 100644 --- a/pdata/ptrace/ptraceotlp/response.go +++ b/pdata/ptrace/ptraceotlp/response.go @@ -7,25 +7,9 @@ import ( "slices" "go.opentelemetry.io/collector/pdata/internal" - otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" "go.opentelemetry.io/collector/pdata/internal/json" ) -// ExportResponse represents the response for gRPC/HTTP client/server. -type ExportResponse struct { - orig *otlpcollectortrace.ExportTraceServiceResponse - state *internal.State -} - -// NewExportResponse returns an empty ExportResponse. -func NewExportResponse() ExportResponse { - state := internal.StateMutable - return ExportResponse{ - orig: &otlpcollectortrace.ExportTraceServiceResponse{}, - state: &state, - } -} - // MarshalProto marshals ExportResponse into proto bytes. func (ms ExportResponse) MarshalProto() ([]byte, error) { return ms.orig.Marshal() @@ -40,10 +24,7 @@ func (ms ExportResponse) UnmarshalProto(data []byte) error { func (ms ExportResponse) MarshalJSON() ([]byte, error) { dest := json.BorrowStream(nil) defer json.ReturnStream(dest) - dest.WriteObjectStart() - dest.WriteObjectField("partialSuccess") - internal.MarshalJSONOrigExportTracePartialSuccess(&ms.orig.PartialSuccess, dest) - dest.WriteObjectEnd() + internal.MarshalJSONOrigExportTraceServiceResponse(ms.orig, dest) return slices.Clone(dest.Buffer()), dest.Error() } @@ -51,23 +32,6 @@ func (ms ExportResponse) MarshalJSON() ([]byte, error) { func (ms ExportResponse) UnmarshalJSON(data []byte) error { iter := json.BorrowIterator(data) defer json.ReturnIterator(iter) - ms.unmarshalJSONIter(iter) + internal.UnmarshalJSONOrigExportTraceServiceResponse(ms.orig, iter) return iter.Error() } - -func (ms ExportResponse) unmarshalJSONIter(iter *json.Iterator) { - iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { - switch f { - case "partial_success", "partialSuccess": - internal.UnmarshalJSONOrigExportTracePartialSuccess(&ms.orig.PartialSuccess, iter) - default: - iter.Skip() - } - return true - }) -} - -// PartialSuccess returns the ExportLogsPartialSuccess associated with this ExportResponse. -func (ms ExportResponse) PartialSuccess() ExportPartialSuccess { - return newExportPartialSuccess(&ms.orig.PartialSuccess, ms.state) -} diff --git a/pdata/ptrace/traces.go b/pdata/ptrace/traces.go index 26948b61267..348ba90460b 100644 --- a/pdata/ptrace/traces.go +++ b/pdata/ptrace/traces.go @@ -5,30 +5,11 @@ package ptrace // import "go.opentelemetry.io/collector/pdata/ptrace" import ( "go.opentelemetry.io/collector/pdata/internal" - otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" - "go.opentelemetry.io/collector/pdata/internal/json" ) -// Traces is the top-level struct that is propagated through the traces pipeline. -// Use NewTraces to create new instance, zero-initialized instance is not valid for use. -type Traces internal.Traces - -func newTraces(orig *otlpcollectortrace.ExportTraceServiceRequest) Traces { - state := internal.StateMutable - return Traces(internal.NewTraces(orig, &state)) -} - -func (ms Traces) getOrig() *otlpcollectortrace.ExportTraceServiceRequest { - return internal.GetOrigTraces(internal.Traces(ms)) -} - -func (ms Traces) getState() *internal.State { - return internal.GetTracesState(internal.Traces(ms)) -} - -// NewTraces creates a new Traces struct. -func NewTraces() Traces { - return newTraces(&otlpcollectortrace.ExportTraceServiceRequest{}) +// MarkReadOnly marks the Traces as shared so that no further modifications can be done on it. +func (ms Traces) MarkReadOnly() { + internal.SetTracesState(internal.Traces(ms), internal.StateReadOnly) } // IsReadOnly returns true if this Traces instance is read-only. @@ -36,11 +17,6 @@ func (ms Traces) IsReadOnly() bool { return *ms.getState() == internal.StateReadOnly } -// CopyTo copies the Traces instance overriding the destination. -func (ms Traces) CopyTo(dest Traces) { - ms.ResourceSpans().CopyTo(dest.ResourceSpans()) -} - // SpanCount calculates the total number of spans. func (ms Traces) SpanCount() int { spanCount := 0 @@ -54,34 +30,3 @@ func (ms Traces) SpanCount() int { } return spanCount } - -// ResourceSpans returns the ResourceSpansSlice associated with this Metrics. -func (ms Traces) ResourceSpans() ResourceSpansSlice { - return newResourceSpansSlice(&ms.getOrig().ResourceSpans, internal.GetTracesState(internal.Traces(ms))) -} - -// MarkReadOnly marks the Traces as shared so that no further modifications can be done on it. -func (ms Traces) MarkReadOnly() { - internal.SetTracesState(internal.Traces(ms), internal.StateReadOnly) -} - -func (ms Traces) marshalJSONStream(dest *json.Stream) { - dest.WriteObjectStart() - if len(ms.getOrig().ResourceSpans) > 0 { - dest.WriteObjectField("resourceSpans") - internal.MarshalJSONOrigResourceSpansSlice(ms.getOrig().ResourceSpans, dest) - } - dest.WriteObjectEnd() -} - -func (ms Traces) unmarshalJSONIter(iter *json.Iterator) { - iter.ReadObjectCB(func(iter *json.Iterator, f string) bool { - switch f { - case "resourceSpans", "resource_spans": - ms.getOrig().ResourceSpans = internal.UnmarshalJSONOrigResourceSpansSlice(iter) - default: - iter.Skip() - } - return true - }) -} diff --git a/pdata/ptrace/traces_test.go b/pdata/ptrace/traces_test.go index 40f5d5b1a48..82d9abd3e69 100644 --- a/pdata/ptrace/traces_test.go +++ b/pdata/ptrace/traces_test.go @@ -46,14 +46,14 @@ func TestSpanCount(t *testing.T) { func TestSpanCountWithEmpty(t *testing.T) { assert.Equal(t, 0, newTraces(&otlpcollectortrace.ExportTraceServiceRequest{ ResourceSpans: []*otlptrace.ResourceSpans{{}}, - }).SpanCount()) + }, new(internal.State)).SpanCount()) assert.Equal(t, 0, newTraces(&otlpcollectortrace.ExportTraceServiceRequest{ ResourceSpans: []*otlptrace.ResourceSpans{ { ScopeSpans: []*otlptrace.ScopeSpans{{}}, }, }, - }).SpanCount()) + }, new(internal.State)).SpanCount()) assert.Equal(t, 1, newTraces(&otlpcollectortrace.ExportTraceServiceRequest{ ResourceSpans: []*otlptrace.ResourceSpans{ { @@ -64,12 +64,12 @@ func TestSpanCountWithEmpty(t *testing.T) { }, }, }, - }).SpanCount()) + }, new(internal.State)).SpanCount()) } func TestToFromOtlp(t *testing.T) { otlp := &otlpcollectortrace.ExportTraceServiceRequest{} - traces := newTraces(otlp) + traces := newTraces(otlp, new(internal.State)) assert.Equal(t, NewTraces(), traces) assert.Equal(t, otlp, traces.getOrig()) // More tests in ./tracedata/traces_test.go. Cannot have them here because of @@ -190,9 +190,3 @@ func BenchmarkTracesMarshalJSON(b *testing.B) { require.NotNil(b, jsonBuf) } } - -func generateTestTraces() Traces { - td := NewTraces() - td.getOrig().ResourceSpans = internal.GenerateOrigTestResourceSpansSlice() - return td -}