From d15292cee29e482419b4a393e066f2372ddd309f Mon Sep 17 00:00:00 2001 From: Dmitry Anoshin Date: Fri, 27 Sep 2024 09:54:58 -0700 Subject: [PATCH] Entities support prototype --- Makefile | 6 +- cmd/mdatagen/internal/loader.go | 11 + .../internal/templates/resource.go.tmpl | 16 + cmd/mdatagen/internal/validate.go | 15 + consumer/consumertest/consumer.go | 6 + consumer/consumertest/nop.go | 2 + consumer/entities.go | 43 + exporter/exporter.go | 39 + exporter/exporter_test.go | 4 +- exporter/internal/entities.go | 15 + exporter/internal/otlptext/databuffer.go | 16 + exporter/internal/otlptext/logs.go | 2 +- exporter/internal/otlptext/metrics.go | 2 +- exporter/internal/otlptext/resource.go | 13 + exporter/internal/otlptext/traces.go | 2 +- .../cmd/pdatagen/internal/base_slices.go | 187 ++- .../cmd/pdatagen/internal/base_structs.go | 10 +- .../cmd/pdatagen/internal/packages.go | 2 + .../cmd/pdatagen/internal/pcommon_package.go | 35 + .../cmd/pdatagen/internal/pentity_package.go | 120 ++ .../pdatagen/internal/pentityotlp_package.go | 43 + .../entities/v1/entities_service.pb.go | 840 ++++++++++ .../data/protogen/entities/v1/entities.pb.go | 1466 +++++++++++++++++ .../internal/data/protogen/logs/v1/logs.pb.go | 2 + .../data/protogen/metrics/v1/metrics.pb.go | 21 + .../data/protogen/resource/v1/resource.pb.go | 461 +++++- .../data/protogen/trace/v1/trace.pb.go | 2 + pdata/internal/generated_wrapper_resource.go | 1 + .../generated_wrapper_resourceentityref.go | 43 + ...enerated_wrapper_resourceentityrefslice.go | 44 + pdata/internal/wrapper_entities.go | 46 + pdata/pcommon/generated_resource.go | 6 + pdata/pcommon/generated_resource_test.go | 7 + pdata/pcommon/generated_resourceentityref.go | 90 + .../generated_resourceentityref_test.go | 73 + .../generated_resourceentityrefslice.go | 157 ++ .../generated_resourceentityrefslice_test.go | 143 ++ pdata/pentity/entities.go | 62 + pdata/pentity/event_type.go | 27 + pdata/pentity/generated_entitydelete.go | 59 + pdata/pentity/generated_entitydelete_test.go | 48 + pdata/pentity/generated_entityevent.go | 161 ++ pdata/pentity/generated_entityevent_test.go | 121 ++ pdata/pentity/generated_entityeventslice.go | 160 ++ .../generated_entityeventslice_test.go | 154 ++ pdata/pentity/generated_entitystate.go | 78 + pdata/pentity/generated_entitystate_test.go | 69 + pdata/pentity/generated_entitystateslice.go | 152 ++ .../generated_entitystateslice_test.go | 154 ++ pdata/pentity/generated_scopeentities.go | 84 + pdata/pentity/generated_scopeentities_test.go | 76 + pdata/pentity/generated_scopeentitiesslice.go | 160 ++ .../generated_scopeentitiesslice_test.go | 154 ++ .../generated_exportpartialsuccess.go | 83 + .../generated_exportpartialsuccess_test.go | 78 + pdata/plog/generated_logrecord.go | 8 + pdata/plog/generated_logrecordslice.go | 66 +- pdata/plog/generated_logrecordslice_test.go | 12 +- pdata/plog/generated_resourcelogs.go | 8 + pdata/plog/generated_resourcelogsslice.go | 66 +- .../plog/generated_resourcelogsslice_test.go | 12 +- pdata/plog/generated_scopelogs.go | 8 + pdata/plog/generated_scopelogsslice.go | 66 +- pdata/plog/generated_scopelogsslice_test.go | 12 +- .../generated_exportpartialsuccess.go | 8 + pdata/pmetric/generated_exemplar.go | 8 + pdata/pmetric/generated_exemplarslice.go | 58 +- pdata/pmetric/generated_exemplarslice_test.go | 4 +- .../pmetric/generated_exponentialhistogram.go | 8 + ...generated_exponentialhistogramdatapoint.go | 8 + ...ed_exponentialhistogramdatapointbuckets.go | 8 + ...ated_exponentialhistogramdatapointslice.go | 66 +- ...exponentialhistogramdatapointslice_test.go | 12 +- pdata/pmetric/generated_gauge.go | 8 + pdata/pmetric/generated_histogram.go | 8 + pdata/pmetric/generated_histogramdatapoint.go | 8 + .../generated_histogramdatapointslice.go | 66 +- .../generated_histogramdatapointslice_test.go | 12 +- pdata/pmetric/generated_metric.go | 8 + pdata/pmetric/generated_metricslice.go | 66 +- pdata/pmetric/generated_metricslice_test.go | 12 +- pdata/pmetric/generated_numberdatapoint.go | 8 + .../pmetric/generated_numberdatapointslice.go | 66 +- .../generated_numberdatapointslice_test.go | 12 +- pdata/pmetric/generated_resourcemetrics.go | 8 + .../pmetric/generated_resourcemetricsslice.go | 66 +- .../generated_resourcemetricsslice_test.go | 12 +- pdata/pmetric/generated_scopemetrics.go | 8 + pdata/pmetric/generated_scopemetricsslice.go | 66 +- .../generated_scopemetricsslice_test.go | 12 +- pdata/pmetric/generated_sum.go | 8 + pdata/pmetric/generated_summary.go | 8 + pdata/pmetric/generated_summarydatapoint.go | 8 + .../generated_summarydatapointslice.go | 66 +- .../generated_summarydatapointslice_test.go | 12 +- ...nerated_summarydatapointvalueatquantile.go | 8 + ...ed_summarydatapointvalueatquantileslice.go | 66 +- ...mmarydatapointvalueatquantileslice_test.go | 12 +- .../generated_exportpartialsuccess.go | 8 + pdata/pprofile/generated_attributeunit.go | 8 + .../pprofile/generated_attributeunitslice.go | 58 +- .../generated_attributeunitslice_test.go | 4 +- pdata/pprofile/generated_function.go | 8 + pdata/pprofile/generated_functionslice.go | 58 +- .../pprofile/generated_functionslice_test.go | 4 +- pdata/pprofile/generated_label.go | 8 + pdata/pprofile/generated_labelslice.go | 58 +- pdata/pprofile/generated_labelslice_test.go | 4 +- pdata/pprofile/generated_line.go | 8 + pdata/pprofile/generated_lineslice.go | 58 +- pdata/pprofile/generated_lineslice_test.go | 4 +- pdata/pprofile/generated_link.go | 8 + pdata/pprofile/generated_linkslice.go | 58 +- pdata/pprofile/generated_linkslice_test.go | 4 +- pdata/pprofile/generated_location.go | 8 + pdata/pprofile/generated_locationslice.go | 58 +- .../pprofile/generated_locationslice_test.go | 4 +- pdata/pprofile/generated_mapping.go | 8 + pdata/pprofile/generated_mappingslice.go | 58 +- pdata/pprofile/generated_mappingslice_test.go | 4 +- pdata/pprofile/generated_profile.go | 8 + pdata/pprofile/generated_profilecontainer.go | 8 + .../generated_profilescontainersslice.go | 66 +- .../generated_profilescontainersslice_test.go | 12 +- pdata/pprofile/generated_resourceprofiles.go | 8 + .../generated_resourceprofilesslice.go | 66 +- .../generated_resourceprofilesslice_test.go | 12 +- pdata/pprofile/generated_sample.go | 8 + pdata/pprofile/generated_sampleslice.go | 58 +- pdata/pprofile/generated_sampleslice_test.go | 4 +- pdata/pprofile/generated_scopeprofiles.go | 8 + .../pprofile/generated_scopeprofilesslice.go | 66 +- .../generated_scopeprofilesslice_test.go | 12 +- pdata/pprofile/generated_valuetype.go | 8 + pdata/pprofile/generated_valuetypeslice.go | 58 +- .../pprofile/generated_valuetypeslice_test.go | 4 +- .../generated_exportpartialsuccess.go | 8 + pdata/ptrace/generated_resourcespans.go | 8 + pdata/ptrace/generated_resourcespansslice.go | 66 +- .../generated_resourcespansslice_test.go | 12 +- pdata/ptrace/generated_scopespans.go | 8 + pdata/ptrace/generated_scopespansslice.go | 66 +- .../ptrace/generated_scopespansslice_test.go | 12 +- pdata/ptrace/generated_span.go | 8 + pdata/ptrace/generated_spanevent.go | 8 + pdata/ptrace/generated_spaneventslice.go | 66 +- pdata/ptrace/generated_spaneventslice_test.go | 12 +- pdata/ptrace/generated_spanlink.go | 8 + pdata/ptrace/generated_spanlinkslice.go | 66 +- pdata/ptrace/generated_spanlinkslice_test.go | 12 +- pdata/ptrace/generated_spanslice.go | 66 +- pdata/ptrace/generated_spanslice_test.go | 12 +- pdata/ptrace/generated_status.go | 8 + .../generated_exportpartialsuccess.go | 8 + processor/internal/entities.go | 15 + processor/processor.go | 40 + processor/processor_test.go | 2 + receiver/receiver.go | 49 +- 158 files changed, 7395 insertions(+), 1012 deletions(-) create mode 100644 consumer/entities.go create mode 100644 exporter/internal/entities.go create mode 100644 exporter/internal/otlptext/resource.go create mode 100644 pdata/internal/cmd/pdatagen/internal/pentity_package.go create mode 100644 pdata/internal/cmd/pdatagen/internal/pentityotlp_package.go create mode 100644 pdata/internal/data/protogen/collector/entities/v1/entities_service.pb.go create mode 100644 pdata/internal/data/protogen/entities/v1/entities.pb.go create mode 100644 pdata/internal/generated_wrapper_resourceentityref.go create mode 100644 pdata/internal/generated_wrapper_resourceentityrefslice.go create mode 100644 pdata/internal/wrapper_entities.go create mode 100644 pdata/pcommon/generated_resourceentityref.go create mode 100644 pdata/pcommon/generated_resourceentityref_test.go create mode 100644 pdata/pcommon/generated_resourceentityrefslice.go create mode 100644 pdata/pcommon/generated_resourceentityrefslice_test.go create mode 100644 pdata/pentity/entities.go create mode 100644 pdata/pentity/event_type.go create mode 100644 pdata/pentity/generated_entitydelete.go create mode 100644 pdata/pentity/generated_entitydelete_test.go create mode 100644 pdata/pentity/generated_entityevent.go create mode 100644 pdata/pentity/generated_entityevent_test.go create mode 100644 pdata/pentity/generated_entityeventslice.go create mode 100644 pdata/pentity/generated_entityeventslice_test.go create mode 100644 pdata/pentity/generated_entitystate.go create mode 100644 pdata/pentity/generated_entitystate_test.go create mode 100644 pdata/pentity/generated_entitystateslice.go create mode 100644 pdata/pentity/generated_entitystateslice_test.go create mode 100644 pdata/pentity/generated_scopeentities.go create mode 100644 pdata/pentity/generated_scopeentities_test.go create mode 100644 pdata/pentity/generated_scopeentitiesslice.go create mode 100644 pdata/pentity/generated_scopeentitiesslice_test.go create mode 100644 pdata/pentity/pentityotlp/generated_exportpartialsuccess.go create mode 100644 pdata/pentity/pentityotlp/generated_exportpartialsuccess_test.go create mode 100644 processor/internal/entities.go diff --git a/Makefile b/Makefile index 404c97632a9..2be709608c3 100644 --- a/Makefile +++ b/Makefile @@ -200,7 +200,7 @@ genproto: genproto-cleanup # Call a sub-make to ensure OPENTELEMETRY_PROTO_FILES is populated $(MAKE) genproto_sub $(MAKE) fmt - $(MAKE) genproto-cleanup + # $(MAKE) genproto-cleanup genproto_sub: @echo Generating code for the following files: @@ -234,8 +234,8 @@ genproto_sub: cp -R $(PROTO_INTERMEDIATE_DIR)/$(PROTO_PACKAGE)/* $(PROTO_TARGET_GEN_DIR)/ rm -rf $(PROTO_INTERMEDIATE_DIR)/go.opentelemetry.io - @rm -rf $(OPENTELEMETRY_PROTO_SRC_DIR)/* - @rm -rf $(OPENTELEMETRY_PROTO_SRC_DIR)/.* > /dev/null 2>&1 || true + #@rm -rf $(OPENTELEMETRY_PROTO_SRC_DIR)/* + #@rm -rf $(OPENTELEMETRY_PROTO_SRC_DIR)/.* > /dev/null 2>&1 || true # Generate structs, functions and tests for pdata package. Must be used after any changes # to proto and after running `make genproto` diff --git a/cmd/mdatagen/internal/loader.go b/cmd/mdatagen/internal/loader.go index cdc59066f4e..857c67f67f9 100644 --- a/cmd/mdatagen/internal/loader.go +++ b/cmd/mdatagen/internal/loader.go @@ -269,6 +269,15 @@ func (t telemetry) Levels() map[string]interface{} { return levels } +type Entity struct { + // Type of the entity. + Type string `mapstructure:"type"` + // Identifying attributes of the entity. + IDAttributes []AttributeName `mapstructure:"id_attributes"` + // Descriptive attributes of the entity. + DescriptiveAttributes []AttributeName `mapstructure:"descriptive_attributes"` +} + type Metadata struct { // Type of the component. Type string `mapstructure:"type"` @@ -282,6 +291,8 @@ type Metadata struct { SemConvVersion string `mapstructure:"sem_conv_version"` // ResourceAttributes that can be emitted by the component. ResourceAttributes map[AttributeName]Attribute `mapstructure:"resource_attributes"` + // Entities associated with the emitted resource attributes. + Entities []Entity `mapstructure:"entities"` // Attributes emitted by one or more metrics. Attributes map[AttributeName]Attribute `mapstructure:"attributes"` // Metrics that can be emitted by the component. diff --git a/cmd/mdatagen/internal/templates/resource.go.tmpl b/cmd/mdatagen/internal/templates/resource.go.tmpl index aa6b8e8b685..4ee3112d224 100644 --- a/cmd/mdatagen/internal/templates/resource.go.tmpl +++ b/cmd/mdatagen/internal/templates/resource.go.tmpl @@ -46,6 +46,22 @@ func (rb *ResourceBuilder) Set{{ $name.Render }}(val {{ $attr.Type.Primitive }}) // Emit returns the built resource and resets the internal builder state. func (rb *ResourceBuilder) Emit() pcommon.Resource { r := rb.res + {{- range $entity := .Entities }} + {{- range $attr := .IDAttributes }} + _, found{{ $attr.Render }} := r.Attributes().Get("{{ $attr }}") + {{- end }} + if {{ range $i, $attr := .IDAttributes }}{{ if $i }}&& {{ end }}found{{ $attr.Render }} {{ end }} { + ref := pcommon.NewResourceEntityRef() + ref.SetType("{{ $entity.Type }}") + ref.IdAttrKeys().Append({{ range $i, $attr := .IDAttributes }}{{ if $i }}, {{ end }}"{{ $attr }}"{{ end }}) + {{- range $attr := .DescriptiveAttributes }} + if _, ok := r.Attributes().Get("{{ $attr }}"); ok { + ref.DescrAttrKeys().Append("{{ $attr }}") + } + {{- end }} + ref.CopyTo(r.Entities().AppendEmpty()) + } + {{- end }} rb.res = pcommon.NewResource() return r } diff --git a/cmd/mdatagen/internal/validate.go b/cmd/mdatagen/internal/validate.go index b784a94fbba..1d439d299f1 100644 --- a/cmd/mdatagen/internal/validate.go +++ b/cmd/mdatagen/internal/validate.go @@ -25,6 +25,9 @@ func (md *Metadata) Validate() error { if err := md.validateMetrics(); err != nil { errs = errors.Join(errs, err) } + if err := md.validateEntities(); err != nil { + errs = errors.Join(errs, err) + } return errs } @@ -143,6 +146,18 @@ func (md *Metadata) validateMetrics() error { return errs } +func (md *Metadata) validateEntities() error { + var errs error + for _, entity := range md.Entities { + for _, attr := range append(entity.IDAttributes, entity.DescriptiveAttributes...) { + if _, ok := md.ResourceAttributes[attr]; !ok { + errs = errors.Join(errs, fmt.Errorf("undefined resource attribute: %v", attr)) + } + } + } + return errs +} + func (m *Metric) validate() error { var errs error if m.Description == "" { diff --git a/consumer/consumertest/consumer.go b/consumer/consumertest/consumer.go index 4b699b9449a..78f3bf3d500 100644 --- a/consumer/consumertest/consumer.go +++ b/consumer/consumertest/consumer.go @@ -8,6 +8,7 @@ import ( "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/consumer/consumerprofiles" + "go.opentelemetry.io/collector/pdata/pentity" "go.opentelemetry.io/collector/pdata/plog" "go.opentelemetry.io/collector/pdata/pmetric" "go.opentelemetry.io/collector/pdata/pprofile" @@ -34,6 +35,9 @@ type Consumer interface { // ConsumeProfiles to implement the consumerprofiles.Profiles. ConsumeProfiles(context.Context, pprofile.Profiles) error + // ConsumeEntities to implement the consumer.Entities. + ConsumeEntities(context.Context, pentity.Entities) error + unexported() } @@ -41,6 +45,7 @@ var _ consumer.Logs = (Consumer)(nil) var _ consumer.Metrics = (Consumer)(nil) var _ consumer.Traces = (Consumer)(nil) var _ consumerprofiles.Profiles = (Consumer)(nil) +var _ consumer.Entities = (Consumer)(nil) type nonMutatingConsumer struct{} @@ -55,6 +60,7 @@ type baseConsumer struct { consumer.ConsumeMetricsFunc consumer.ConsumeLogsFunc consumerprofiles.ConsumeProfilesFunc + consumer.ConsumeEntitiesFunc } func (bc baseConsumer) unexported() {} diff --git a/consumer/consumertest/nop.go b/consumer/consumertest/nop.go index 25b898a7751..a36e5014333 100644 --- a/consumer/consumertest/nop.go +++ b/consumer/consumertest/nop.go @@ -6,6 +6,7 @@ package consumertest // import "go.opentelemetry.io/collector/consumer/consumert import ( "context" + "go.opentelemetry.io/collector/pdata/pentity" "go.opentelemetry.io/collector/pdata/plog" "go.opentelemetry.io/collector/pdata/pmetric" "go.opentelemetry.io/collector/pdata/pprofile" @@ -19,5 +20,6 @@ func NewNop() Consumer { ConsumeMetricsFunc: func(context.Context, pmetric.Metrics) error { return nil }, ConsumeLogsFunc: func(context.Context, plog.Logs) error { return nil }, ConsumeProfilesFunc: func(context.Context, pprofile.Profiles) error { return nil }, + ConsumeEntitiesFunc: func(context.Context, pentity.Entities) error { return nil }, } } diff --git a/consumer/entities.go b/consumer/entities.go new file mode 100644 index 00000000000..284488c8bce --- /dev/null +++ b/consumer/entities.go @@ -0,0 +1,43 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package consumer // import "go.opentelemetry.io/collector/consumer" + +import ( + "context" + + "go.opentelemetry.io/collector/consumer/internal" + "go.opentelemetry.io/collector/pdata/pentity" +) + +// Entities is an interface that receives pentity.Entities, processes it +// as needed, and sends it to the next processing node if any or to the destination. +type Entities interface { + internal.BaseConsumer + // ConsumeEntities receives pentity.Entities for consumption. + ConsumeEntities(ctx context.Context, td pentity.Entities) error +} + +// ConsumeEntitiesFunc is a helper function that is similar to ConsumeEntities. +type ConsumeEntitiesFunc func(ctx context.Context, td pentity.Entities) error + +// ConsumeEntities calls f(ctx, td). +func (f ConsumeEntitiesFunc) ConsumeEntities(ctx context.Context, td pentity.Entities) error { + return f(ctx, td) +} + +type baseEntities struct { + *internal.BaseImpl + ConsumeEntitiesFunc +} + +// NewEntities returns a Entities configured with the provided options. +func NewEntities(consume ConsumeEntitiesFunc, options ...Option) (Entities, error) { + if consume == nil { + return nil, errNilFunc + } + return &baseEntities{ + BaseImpl: internal.NewBaseImpl(options...), + ConsumeEntitiesFunc: consume, + }, nil +} diff --git a/exporter/exporter.go b/exporter/exporter.go index 2a427933db7..840c80d6554 100644 --- a/exporter/exporter.go +++ b/exporter/exporter.go @@ -30,6 +30,12 @@ type Logs interface { consumer.Logs } +// Entities is an exporter that can consume entities. +type Entities interface { + component.Component + consumer.Entities +} + // Settings configures exporter creators. type Settings struct { // ID returns the ID of the component that will be created. @@ -72,6 +78,14 @@ type Factory interface { // LogsExporterStability gets the stability level of the LogsExporter. LogsExporterStability() component.StabilityLevel + // CreateEntitiesExporter creates an EntitiesExporter based on the config. + // If the exporter type does not support entities, + // this function returns the error [pipeline.ErrSignalNotSupported]. + CreateEntitiesExporter(ctx context.Context, set Settings, cfg component.Config) (Entities, error) + + // EntityExporterStability gets the stability level of the EntityExporter. + EntityExporterStability() component.StabilityLevel + unexportedFactoryFunc() } @@ -123,6 +137,17 @@ func (f CreateLogsFunc) CreateLogsExporter(ctx context.Context, set Settings, cf return f(ctx, set, cfg) } +// CreateEntitiesFunc is the equivalent of Factory.CreateEntities. +type CreateEntitiesFunc func(context.Context, Settings, component.Config) (Entities, error) + +// CreateEntitiesExporter implements Factory.CreateEntities. +func (f CreateEntitiesFunc) CreateEntitiesExporter(ctx context.Context, set Settings, cfg component.Config) (Entities, error) { + if f == nil { + return nil, pipeline.ErrSignalNotSupported + } + return f(ctx, set, cfg) +} + type factory struct { cfgType component.Type component.CreateDefaultConfigFunc @@ -132,6 +157,8 @@ type factory struct { metricsStabilityLevel component.StabilityLevel CreateLogsFunc logsStabilityLevel component.StabilityLevel + CreateEntitiesFunc + entitiesStabilityLevel component.StabilityLevel } func (f *factory) Type() component.Type { @@ -152,6 +179,10 @@ func (f *factory) LogsExporterStability() component.StabilityLevel { return f.logsStabilityLevel } +func (f *factory) EntityExporterStability() component.StabilityLevel { + return f.entitiesStabilityLevel +} + // WithTraces overrides the default "error not supported" implementation for CreateTracesExporter and the default "undefined" stability level. func WithTraces(createTraces CreateTracesFunc, sl component.StabilityLevel) FactoryOption { return factoryOptionFunc(func(o *factory) { @@ -176,6 +207,14 @@ func WithLogs(createLogs CreateLogsFunc, sl component.StabilityLevel) FactoryOpt }) } +// WithEntities overrides the default "error not supported" implementation for CreateEntitiesExporter and the default "undefined" stability level. +func WithEntities(createEntities CreateEntitiesFunc, sl component.StabilityLevel) FactoryOption { + return factoryOptionFunc(func(o *factory) { + o.entitiesStabilityLevel = sl + o.CreateEntitiesFunc = createEntities + }) +} + // NewFactory returns a Factory. func NewFactory(cfgType component.Type, createDefaultConfig component.CreateDefaultConfigFunc, options ...FactoryOption) Factory { f := &factory{ diff --git a/exporter/exporter_test.go b/exporter/exporter_test.go index 54e23eb3d48..61474354d10 100644 --- a/exporter/exporter_test.go +++ b/exporter/exporter_test.go @@ -27,7 +27,9 @@ func TestNewFactory(t *testing.T) { _, err = factory.CreateMetricsExporter(context.Background(), Settings{}, &defaultCfg) require.Error(t, err) _, err = factory.CreateLogsExporter(context.Background(), Settings{}, &defaultCfg) - assert.Error(t, err) + require.Error(t, err) + _, err = factory.CreateEntitiesExporter(context.Background(), Settings{}, &defaultCfg) + require.Error(t, err) } func TestNewFactoryWithOptions(t *testing.T) { diff --git a/exporter/internal/entities.go b/exporter/internal/entities.go new file mode 100644 index 00000000000..b7cfb5076fa --- /dev/null +++ b/exporter/internal/entities.go @@ -0,0 +1,15 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package internal // import "go.opentelemetry.io/collector/exporter/internal" + +import ( + "go.opentelemetry.io/collector/component" + "go.opentelemetry.io/collector/consumer" +) + +// Profiles is an exporter that can consume profiles. +type Entities interface { + component.Component + consumer.Entities +} diff --git a/exporter/internal/otlptext/databuffer.go b/exporter/internal/otlptext/databuffer.go index cf7fd630e78..e69d1cc7d8b 100644 --- a/exporter/internal/otlptext/databuffer.go +++ b/exporter/internal/otlptext/databuffer.go @@ -280,6 +280,22 @@ func (b *dataBuffer) logExemplars(description string, se pmetric.ExemplarSlice) } } +func (b *dataBuffer) logResourceEntities(rers pcommon.ResourceEntityRefSlice) { + if rers.Len() == 0 { + return + } + + b.logEntry("Entities:") + for i := 0; i < rers.Len(); i++ { + rer := rers.At(i) + b.logEntry("Entity Ref #%d", i) + b.logEntry(" -> Entity Type: %s", rer.Type()) + b.logEntry(" -> SchemaURL: %s", rer.SchemaUrl()) + b.logEntry(" -> Identifying Attributes: %s", strings.Join(rer.IdAttrKeys().AsRaw(), ", ")) + b.logEntry(" -> Descriptive Attributes: %s", strings.Join(rer.DescrAttrKeys().AsRaw(), ", ")) + } +} + func valueToString(v pcommon.Value) string { return fmt.Sprintf("%s(%s)", v.Type().String(), v.AsString()) } diff --git a/exporter/internal/otlptext/logs.go b/exporter/internal/otlptext/logs.go index 9eb7987130c..e4da9d68b9b 100644 --- a/exporter/internal/otlptext/logs.go +++ b/exporter/internal/otlptext/logs.go @@ -22,7 +22,7 @@ func (textLogsMarshaler) MarshalLogs(ld plog.Logs) ([]byte, error) { buf.logEntry("ResourceLog #%d", i) rl := rls.At(i) buf.logEntry("Resource SchemaURL: %s", rl.SchemaUrl()) - buf.logAttributes("Resource attributes", rl.Resource().Attributes()) + marshalResource(rl.Resource(), &buf) ills := rl.ScopeLogs() for j := 0; j < ills.Len(); j++ { buf.logEntry("ScopeLogs #%d", j) diff --git a/exporter/internal/otlptext/metrics.go b/exporter/internal/otlptext/metrics.go index e63a15624e3..16cce64478a 100644 --- a/exporter/internal/otlptext/metrics.go +++ b/exporter/internal/otlptext/metrics.go @@ -20,7 +20,7 @@ func (textMetricsMarshaler) MarshalMetrics(md pmetric.Metrics) ([]byte, error) { buf.logEntry("ResourceMetrics #%d", i) rm := rms.At(i) buf.logEntry("Resource SchemaURL: %s", rm.SchemaUrl()) - buf.logAttributes("Resource attributes", rm.Resource().Attributes()) + marshalResource(rm.Resource(), &buf) ilms := rm.ScopeMetrics() for j := 0; j < ilms.Len(); j++ { buf.logEntry("ScopeMetrics #%d", j) diff --git a/exporter/internal/otlptext/resource.go b/exporter/internal/otlptext/resource.go new file mode 100644 index 00000000000..ad02ccfcefd --- /dev/null +++ b/exporter/internal/otlptext/resource.go @@ -0,0 +1,13 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package otlptext // import "go.opentelemetry.io/collector/exporter/internal/otlptext" + +import ( + "go.opentelemetry.io/collector/pdata/pcommon" +) + +func marshalResource(res pcommon.Resource, buf *dataBuffer) { + buf.logAttributes("Resource attributes", res.Attributes()) + buf.logResourceEntities(res.Entities()) +} diff --git a/exporter/internal/otlptext/traces.go b/exporter/internal/otlptext/traces.go index 5d09a08ebad..79d9ddc2b3b 100644 --- a/exporter/internal/otlptext/traces.go +++ b/exporter/internal/otlptext/traces.go @@ -22,7 +22,7 @@ func (textTracesMarshaler) MarshalTraces(td ptrace.Traces) ([]byte, error) { buf.logEntry("ResourceSpans #%d", i) rs := rss.At(i) buf.logEntry("Resource SchemaURL: %s", rs.SchemaUrl()) - buf.logAttributes("Resource attributes", rs.Resource().Attributes()) + marshalResource(rs.Resource(), &buf) ilss := rs.ScopeSpans() for j := 0; j < ilss.Len(); j++ { buf.logEntry("ScopeSpans #%d", j) diff --git a/pdata/internal/cmd/pdatagen/internal/base_slices.go b/pdata/internal/cmd/pdatagen/internal/base_slices.go index 21646d92bc1..ee322d188d6 100644 --- a/pdata/internal/cmd/pdatagen/internal/base_slices.go +++ b/pdata/internal/cmd/pdatagen/internal/base_slices.go @@ -5,6 +5,7 @@ package internal // import "go.opentelemetry.io/collector/pdata/internal/cmd/pda import ( "bytes" + "strings" "text/template" ) @@ -15,13 +16,37 @@ const sliceTemplate = `// {{ .structName }} logically represents a slice of {{ . // // Must use New{{ .structName }} function to create new instances. // Important: zero-initialized instance is not valid for use. +{{- if .isCommon }} +type {{ .structName }} internal.{{ .structName }} +{{- else }} type {{ .structName }} struct { orig *[]{{ .originElementType }} state *internal.State } +{{- end }} func new{{ .structName }}(orig *[]{{ .originElementType }}, state *internal.State) {{ .structName }} { + {{- if .isCommon }} + return {{ .structName }}(internal.New{{ .structName }}(orig, state)) + {{- else }} return {{ .structName }}{orig: orig, state: state} + {{- end }} +} + +func (ms {{ .structName }}) getOrig() *[]{{ .originElementType }} { + {{- if .isCommon }} + return internal.GetOrig{{ .structName }}(internal.{{ .structName }}(ms)) + {{- else }} + return ms.orig + {{- end }} +} + +func (ms {{ .structName }}) getState() *internal.State { + {{- if .isCommon }} + return internal.Get{{ .structName }}State(internal.{{ .structName }}(ms)) + {{- else }} + return ms.state + {{- end }} } // New{{ .structName }} creates a {{ .structName }} with 0 elements. @@ -36,7 +61,7 @@ func New{{ .structName }}() {{ .structName }} { // // Returns "0" for a newly instance created with "New{{ .structName }}()". func (es {{ .structName }}) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -62,45 +87,45 @@ func (es {{ .structName }}) At(i int) {{ .elementName }} { // // Here should set all the values for e. // } func (es {{ .structName }}) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]{{ .originElementType }}, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]{{ .originElementType }}, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty {{ .elementName }}. // It returns the newly added {{ .elementName }}. func (es {{ .structName }}) AppendEmpty() {{ .elementName }} { - es.state.AssertMutable() - *es.orig = append(*es.orig, {{ .emptyOriginElement }}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), {{ .emptyOriginElement }}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es {{ .structName }}) MoveAndAppendTo(dest {{ .structName }}) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es {{ .structName }}) RemoveIf(f func({{ .elementName }}) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -109,41 +134,41 @@ func (es {{ .structName }}) RemoveIf(f func({{ .elementName }}) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es {{ .structName }}) CopyTo(dest {{ .structName }}) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] {{- if eq .type "sliceOfPtrs" }} - for i := range *es.orig { - new{{ .elementName }}((*es.orig)[i], es.state).CopyTo(new{{ .elementName }}((*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + new{{ .elementName }}((*es.getOrig())[i], es.getState()).CopyTo(new{{ .elementName }}((*dest.getOrig())[i], dest.getState())) } return } origs := make([]{{ .originName }}, srcLen) wrappers := make([]*{{ .originName }}, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - new{{ .elementName }}((*es.orig)[i], es.state).CopyTo(new{{ .elementName }}(wrappers[i], dest.state)) + new{{ .elementName }}((*es.getOrig())[i], es.getState()).CopyTo(new{{ .elementName }}(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers {{- else }} } else { - (*dest.orig) = make([]{{ .originElementType }}, srcLen) + (*dest.getOrig()) = make([]{{ .originElementType }}, srcLen) } - for i := range *es.orig { - {{ .newElement }}.CopyTo(new{{ .elementName }}(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + {{ .newElement }}.CopyTo(new{{ .elementName }}(&(*dest.getOrig())[i], dest.getState())) } {{- end }} } @@ -153,8 +178,8 @@ func (es {{ .structName }}) CopyTo(dest {{ .structName }}) { // provided less function so that two instances of {{ .structName }} // can be compared. func (es {{ .structName }}) Sort(less func(a, b {{ .elementName }}) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } {{- end }}` @@ -166,11 +191,19 @@ const sliceTestTemplate = `func Test{{ .structName }}(t *testing.T) { assert.Equal(t, 0, es.Len()) emptyVal := New{{ .elementName }}() + {{- if .isCommon }} + testVal := {{ .elementName }}(internal.GenerateTest{{ .elementName }}()) + {{- else }} testVal := generateTest{{ .elementName }}() + {{- end }} for i := 0; i < 7; i++ { el := es.AppendEmpty() assert.Equal(t, emptyVal, es.At(i)) + {{- if .isCommon }} + internal.FillTest{{ .elementName }}(internal.{{ .elementName }}(el)) + {{- else }} fillTest{{ .elementName }}(el) + {{- end }} assert.Equal(t, testVal, es.At(i)) } assert.Equal(t, 7, es.Len()) @@ -211,14 +244,14 @@ func Test{{ .structName }}_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTest{{ .structName }}(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTest{{ .structName }}().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTest{{ .structName }}(), es) } @@ -269,34 +302,62 @@ func Test{{ .structName }}_RemoveIf(t *testing.T) { func Test{{ .structName }}_Sort(t *testing.T) { es := generateTest{{ .structName }}() es.Sort(func(a, b {{ .elementName }}) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b {{ .elementName }}) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } +{{- end }} + +{{- if .isCommon }} +func generateTest{{ .structName }}() {{ .structName }} { + return {{ .structName }}(internal.GenerateTest{{ .structName }}()) +} {{- end }}` -const sliceGenerateTest = `func generateTest{{ .structName }}() {{ .structName }} { - es := New{{ .structName }}() - fillTest{{ .structName }}(es) +const sliceGenerateTest = `func {{ upperIfInternal "g" }}enerateTest{{ .structName }}() {{ .structName }} { + {{- if .isCommon }} + orig := []{{ .originElementType }}(nil) + state := StateMutable + {{- end }} + es := New{{ .structName }}({{ if .isCommon }}&orig, &state{{ end }}) + {{ upperIfInternal "f" }}illTest{{ .structName }}(es) return es } -func fillTest{{ .structName }}(es {{ .structName }}) { +func {{ upperIfInternal "f" }}illTest{{ .structName }}(es {{ .structName }}) { *es.orig = make([]{{ .originElementType }}, 7) for i := 0; i < 7; i++ { (*es.orig)[i] = {{ .emptyOriginElement }} - fillTest{{ .elementName }}({{ .newElement }}) + {{ upperIfInternal "f" }}illTest{{ .elementName }}({{ upperIfInternal "n" }}ew{{ .elementName }}({{ .elementGetter }}, es.state)) } }` +const sliceValueAliasTemplate = ` +type {{ .structName }} struct { + orig *[]{{ .originElementType }} + state *State +} + +func GetOrig{{ .structName }}(ms {{ .structName }}) *[]{{ .originElementType }} { + return ms.orig +} + +func Get{{ .structName }}State(ms {{ .structName }}) *State { + return ms.state +} + +func New{{ .structName }}(orig *[]{{ .originElementType }}, state *State) {{ .structName }} { + return {{ .structName }}{orig: orig, state: state} +}` + type baseSlice interface { getName() string getPackageName() string @@ -332,25 +393,44 @@ func (ss *sliceOfPtrs) generateTests(sb *bytes.Buffer) { } func (ss *sliceOfPtrs) generateTestValueHelpers(sb *bytes.Buffer) { - t := template.Must(template.New("sliceGenerateTest").Parse(sliceGenerateTest)) + funcs := template.FuncMap{ + "upperIfInternal": func(in string) string { + if usedByOtherDataTypes(ss.packageName) { + return strings.ToUpper(in) + } + return in + }, + } + t := template.Must(template.New("sliceGenerateTest").Funcs(funcs).Parse(sliceGenerateTest)) if err := t.Execute(sb, ss.templateFields()); err != nil { panic(err) } } func (ss *sliceOfPtrs) templateFields() map[string]any { + newElement := "new" + ss.element.structName + "((*es.getOrig())[i], es.getState())" + if usedByOtherDataTypes(ss.packageName) { + newElement = ss.element.structName + "(internal.New" + ss.element.structName + "((*es.getOrig())[i], es.getState()))" + } return map[string]any{ "type": "sliceOfPtrs", + "isCommon": usedByOtherDataTypes(ss.packageName), "structName": ss.structName, "elementName": ss.element.structName, "originName": ss.element.originFullName, "originElementType": "*" + ss.element.originFullName, "emptyOriginElement": "&" + ss.element.originFullName + "{}", - "newElement": "new" + ss.element.structName + "((*es.orig)[i], es.state)", + "newElement": newElement, + "elementGetter": "(*es.orig)[i]", } } -func (ss *sliceOfPtrs) generateInternal(*bytes.Buffer) {} +func (ss *sliceOfPtrs) generateInternal(sb *bytes.Buffer) { + t := template.Must(template.New("sliceValueAliasTemplate").Parse(sliceValueAliasTemplate)) + if err := t.Execute(sb, ss.templateFields()); err != nil { + panic(err) + } +} var _ baseStruct = (*sliceOfPtrs)(nil) @@ -384,13 +464,25 @@ func (ss *sliceOfValues) generateTests(sb *bytes.Buffer) { } func (ss *sliceOfValues) generateTestValueHelpers(sb *bytes.Buffer) { - t := template.Must(template.New("sliceGenerateTest").Parse(sliceGenerateTest)) + funcs := template.FuncMap{ + "upperIfInternal": func(in string) string { + if usedByOtherDataTypes(ss.packageName) { + return strings.ToUpper(in) + } + return in + }, + } + t := template.Must(template.New("sliceGenerateTest").Funcs(funcs).Parse(sliceGenerateTest)) if err := t.Execute(sb, ss.templateFields()); err != nil { panic(err) } } func (ss *sliceOfValues) templateFields() map[string]any { + newElement := "new" + ss.element.structName + "(&(*es.getOrig())[i], es.getState())" + if usedByOtherDataTypes(ss.packageName) { + newElement = ss.element.structName + "(internal.New" + ss.element.structName + "(&(*es.getOrig())[i], es.getState()))" + } return map[string]any{ "type": "sliceOfValues", "structName": ss.structName, @@ -398,7 +490,8 @@ func (ss *sliceOfValues) templateFields() map[string]any { "originName": ss.element.originFullName, "originElementType": ss.element.originFullName, "emptyOriginElement": ss.element.originFullName + "{}", - "newElement": "new" + ss.element.structName + "(&(*es.orig)[i], es.state)", + "newElement": newElement, + "elementGetter": "&(*es.orig)[i]", } } diff --git a/pdata/internal/cmd/pdatagen/internal/base_structs.go b/pdata/internal/cmd/pdatagen/internal/base_structs.go index 859bb4d7c05..604a2aafdf9 100644 --- a/pdata/internal/cmd/pdatagen/internal/base_structs.go +++ b/pdata/internal/cmd/pdatagen/internal/base_structs.go @@ -51,15 +51,21 @@ func (ms {{ .structName }}) MoveTo(dest {{ .structName }}) { *ms.{{ .origAccessor }} = {{ .originName }}{} } -{{ if .isCommon -}} func (ms {{ .structName }}) getOrig() *{{ .originName }} { + {{- if .isCommon -}} return internal.GetOrig{{ .structName }}(internal.{{ .structName }}(ms)) + {{- else }} + return ms.orig + {{- end }} } func (ms {{ .structName }}) getState() *internal.State { + {{- if .isCommon -}} return internal.Get{{ .structName }}State(internal.{{ .structName }}(ms)) + {{- else }} + return ms.state + {{- end }} } -{{- end }} {{ range .fields -}} {{ .GenerateAccessors $.messageStruct }} diff --git a/pdata/internal/cmd/pdatagen/internal/packages.go b/pdata/internal/cmd/pdatagen/internal/packages.go index 13d98d6703c..a01fd7cead5 100644 --- a/pdata/internal/cmd/pdatagen/internal/packages.go +++ b/pdata/internal/cmd/pdatagen/internal/packages.go @@ -19,6 +19,8 @@ const header = `// Copyright The OpenTelemetry Authors // AllPackages is a list of all packages that needs to be generated. var AllPackages = []*Package{ pcommon, + pentity, + pentityotlp, plog, plogotlp, pmetric, diff --git a/pdata/internal/cmd/pdatagen/internal/pcommon_package.go b/pdata/internal/cmd/pdatagen/internal/pcommon_package.go index 6491792b4cf..ec8ff71cf69 100644 --- a/pdata/internal/cmd/pdatagen/internal/pcommon_package.go +++ b/pdata/internal/cmd/pdatagen/internal/pcommon_package.go @@ -21,6 +21,8 @@ var pcommon = &Package{ structs: []baseStruct{ scope, resource, + entityRefSlice, + entityRef, byteSlice, float64Slice, uInt64Slice, @@ -157,6 +159,10 @@ var resource = &messageValueStruct{ fields: []baseField{ attributes, droppedAttributesCount, + &sliceField{ + fieldName: "Entities", + returnSlice: entityRefSlice, + }, }, } @@ -165,6 +171,35 @@ var resourceField = &messageValueField{ returnMessage: resource, } +var entityRefSlice = &sliceOfPtrs{ + structName: "ResourceEntityRefSlice", + packageName: "pcommon", + element: entityRef, +} + +var entityRef = &messageValueStruct{ + structName: "ResourceEntityRef", + packageName: "pcommon", + originFullName: "otlpresource.ResourceEntityRef", + fields: []baseField{ + schemaURLField, + &primitiveField{ + fieldName: "Type", + returnType: "string", + defaultVal: `""`, + testVal: `"host"`, + }, + &sliceField{ + fieldName: "IdAttrKeys", + returnSlice: stringSlice, + }, + &sliceField{ + fieldName: "DescrAttrKeys", + returnSlice: stringSlice, + }, + }, +} + var byteSlice = &primitiveSliceStruct{ structName: "ByteSlice", packageName: "pcommon", diff --git a/pdata/internal/cmd/pdatagen/internal/pentity_package.go b/pdata/internal/cmd/pdatagen/internal/pentity_package.go new file mode 100644 index 00000000000..c58ea5f3658 --- /dev/null +++ b/pdata/internal/cmd/pdatagen/internal/pentity_package.go @@ -0,0 +1,120 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package internal // import "go.opentelemetry.io/collector/pdata/internal/cmd/pdatagen/internal" + +var pentity = &Package{ + name: "pentity", + path: "pentity", + imports: []string{ + `"sort"`, + ``, + `"go.opentelemetry.io/collector/pdata/internal"`, + `"go.opentelemetry.io/collector/pdata/internal/data"`, + `otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1"`, + `"go.opentelemetry.io/collector/pdata/pcommon"`, + }, + testImports: []string{ + `"testing"`, + `"unsafe"`, + ``, + `"github.com/stretchr/testify/assert"`, + ``, + `"go.opentelemetry.io/collector/pdata/internal"`, + `"go.opentelemetry.io/collector/pdata/internal/data"`, + `otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1"`, + `"go.opentelemetry.io/collector/pdata/pcommon"`, + }, + structs: []baseStruct{ + scopeEntitiesSlice, + scopeEntities, + entityEventSlice, + entityEvent, + entityState, + entityDelete, + }, +} + +var scopeEntitiesSlice = &sliceOfPtrs{ + structName: "ScopeEntitiesSlice", + element: scopeEntities, +} + +var scopeEntities = &messageValueStruct{ + structName: "ScopeEntities", + description: "// ScopeEntities is a collection of entities from a LibraryInstrumentation.", + originFullName: "otlpentities.ScopeEntities", + fields: []baseField{ + scopeField, + schemaURLField, + &sliceField{ + fieldName: "EntityEvents", + returnSlice: entityEventSlice, + }, + }, +} + +var entityEventSlice = &sliceOfPtrs{ + structName: "EntityEventSlice", + element: entityEvent, +} + +var entityEvent = &messageValueStruct{ + structName: "EntityEvent", + description: "// EntityEvent are experimental implementation of OpenTelemetry Entity Data Model.\n", + originFullName: "otlpentities.EntityEvent", + fields: []baseField{ + &primitiveTypedField{ + fieldName: "Timestamp", + originFieldName: "TimeUnixNano", + returnType: timestampType, + }, + &primitiveField{ + fieldName: "EntityType", + returnType: "string", + defaultVal: `""`, + testVal: `"service"`, + }, + entityID, + &oneOfField{ + typeName: "EventType", + originFieldName: "Data", + testValueIdx: 1, // Delete + omitOriginFieldNameInNames: true, + values: []oneOfValue{ + &oneOfMessageValue{ + fieldName: "EntityState", + originFieldPackageName: "otlpentities", + returnMessage: entityState, + }, + &oneOfMessageValue{ + fieldName: "EntityDelete", + originFieldPackageName: "otlpentities", + returnMessage: entityDelete, + }, + }, + }, + }, +} + +var entityID = &sliceField{ + fieldName: "Id", + returnSlice: mapStruct, +} + +var entityState = &messageValueStruct{ + structName: "EntityState", + description: "// EntityState are experimental implementation of OpenTelemetry Entity Data Model.\n", + originFullName: "otlpentities.EntityState", + fields: []baseField{ + attributes, + droppedAttributesCount, + }, +} + +var entityDelete = &messageValueStruct{ + structName: "EntityDelete", + description: "// EntityDelete are experimental implementation of OpenTelemetry Entity Data Model.\n", + originFullName: "otlpentities.EntityDelete", + fields: []baseField{}, +} diff --git a/pdata/internal/cmd/pdatagen/internal/pentityotlp_package.go b/pdata/internal/cmd/pdatagen/internal/pentityotlp_package.go new file mode 100644 index 00000000000..d8c1d13a093 --- /dev/null +++ b/pdata/internal/cmd/pdatagen/internal/pentityotlp_package.go @@ -0,0 +1,43 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package internal // import "go.opentelemetry.io/collector/pdata/internal/cmd/pdatagen/internal" +import ( + "path/filepath" +) + +var pentityotlp = &Package{ + name: "pentityotlp", + path: filepath.Join("pentity", "pentityotlp"), + imports: []string{ + `otlpcollectorentity "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/entities/v1"`, + }, + testImports: []string{ + `"testing"`, + ``, + `"github.com/stretchr/testify/assert"`, + }, + structs: []baseStruct{ + exportEntitiesPartialSuccess, + }, +} + +var exportEntitiesPartialSuccess = &messageValueStruct{ + structName: "ExportPartialSuccess", + description: "// ExportPartialSuccess represents the details of a partially successful export request.", + originFullName: "otlpcollectorentity.ExportEntitiesPartialSuccess", + fields: []baseField{ + &primitiveField{ + fieldName: "RejectedEntities", + returnType: "int64", + defaultVal: `int64(0)`, + testVal: `int64(13)`, + }, + &primitiveField{ + fieldName: "ErrorMessage", + returnType: "string", + defaultVal: `""`, + testVal: `"error message"`, + }, + }, +} diff --git a/pdata/internal/data/protogen/collector/entities/v1/entities_service.pb.go b/pdata/internal/data/protogen/collector/entities/v1/entities_service.pb.go new file mode 100644 index 00000000000..7a190a740e0 --- /dev/null +++ b/pdata/internal/data/protogen/collector/entities/v1/entities_service.pb.go @@ -0,0 +1,840 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: opentelemetry/proto/collector/entities/v1/entities_service.proto + +package v1 + +import ( + context "context" + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + + v1 "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type ExportEntitiesServiceRequest struct { + // An array of ResourceEntities. + ScopeEntities []*v1.ScopeEntities `protobuf:"bytes,1,rep,name=scope_entities,json=scopeEntities,proto3" json:"scope_entities,omitempty"` +} + +func (m *ExportEntitiesServiceRequest) Reset() { *m = ExportEntitiesServiceRequest{} } +func (m *ExportEntitiesServiceRequest) String() string { return proto.CompactTextString(m) } +func (*ExportEntitiesServiceRequest) ProtoMessage() {} +func (*ExportEntitiesServiceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_fbd01640b6ae8848, []int{0} +} +func (m *ExportEntitiesServiceRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExportEntitiesServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExportEntitiesServiceRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ExportEntitiesServiceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExportEntitiesServiceRequest.Merge(m, src) +} +func (m *ExportEntitiesServiceRequest) XXX_Size() int { + return m.Size() +} +func (m *ExportEntitiesServiceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ExportEntitiesServiceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ExportEntitiesServiceRequest proto.InternalMessageInfo + +func (m *ExportEntitiesServiceRequest) GetScopeEntities() []*v1.ScopeEntities { + if m != nil { + return m.ScopeEntities + } + return nil +} + +type ExportEntitiesServiceResponse struct { + // The details of a partially successful export request. + // + // If the request is only partially accepted + // (i.e. when the server accepts only parts of the data and rejects the rest) + // the server MUST initialize the `partial_success` field and MUST + // set the `rejected_` with the number of items it rejected. + // + // Servers MAY also make use of the `partial_success` field to convey + // warnings/suggestions to senders even when the request was fully accepted. + // In such cases, the `rejected_` MUST have a value of `0` and + // the `error_message` MUST be non-empty. + // + // A `partial_success` message with an empty value (rejected_ = 0 and + // `error_message` = "") is equivalent to it not being set/present. Senders + // SHOULD interpret it the same way as in the full success case. + PartialSuccess ExportEntitiesPartialSuccess `protobuf:"bytes,1,opt,name=partial_success,json=partialSuccess,proto3" json:"partial_success"` +} + +func (m *ExportEntitiesServiceResponse) Reset() { *m = ExportEntitiesServiceResponse{} } +func (m *ExportEntitiesServiceResponse) String() string { return proto.CompactTextString(m) } +func (*ExportEntitiesServiceResponse) ProtoMessage() {} +func (*ExportEntitiesServiceResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_fbd01640b6ae8848, []int{1} +} +func (m *ExportEntitiesServiceResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExportEntitiesServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExportEntitiesServiceResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ExportEntitiesServiceResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExportEntitiesServiceResponse.Merge(m, src) +} +func (m *ExportEntitiesServiceResponse) XXX_Size() int { + return m.Size() +} +func (m *ExportEntitiesServiceResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ExportEntitiesServiceResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ExportEntitiesServiceResponse proto.InternalMessageInfo + +func (m *ExportEntitiesServiceResponse) GetPartialSuccess() ExportEntitiesPartialSuccess { + if m != nil { + return m.PartialSuccess + } + return ExportEntitiesPartialSuccess{} +} + +type ExportEntitiesPartialSuccess struct { + // The number of rejected log records. + // + // A `rejected_` field holding a `0` value indicates that the + // request was fully accepted. + RejectedEntities int64 `protobuf:"varint,1,opt,name=rejected_entities,json=rejectedEntities,proto3" json:"rejected_entities,omitempty"` + // A developer-facing human-readable message in English. It should be used + // either to explain why the server rejected parts of the data during a partial + // success or to convey warnings/suggestions during a full success. The message + // should offer guidance on how users can address such issues. + // + // error_message is an optional field. An error_message with an empty value + // is equivalent to it not being set. + ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"` +} + +func (m *ExportEntitiesPartialSuccess) Reset() { *m = ExportEntitiesPartialSuccess{} } +func (m *ExportEntitiesPartialSuccess) String() string { return proto.CompactTextString(m) } +func (*ExportEntitiesPartialSuccess) ProtoMessage() {} +func (*ExportEntitiesPartialSuccess) Descriptor() ([]byte, []int) { + return fileDescriptor_fbd01640b6ae8848, []int{2} +} +func (m *ExportEntitiesPartialSuccess) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExportEntitiesPartialSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExportEntitiesPartialSuccess.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ExportEntitiesPartialSuccess) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExportEntitiesPartialSuccess.Merge(m, src) +} +func (m *ExportEntitiesPartialSuccess) XXX_Size() int { + return m.Size() +} +func (m *ExportEntitiesPartialSuccess) XXX_DiscardUnknown() { + xxx_messageInfo_ExportEntitiesPartialSuccess.DiscardUnknown(m) +} + +var xxx_messageInfo_ExportEntitiesPartialSuccess proto.InternalMessageInfo + +func (m *ExportEntitiesPartialSuccess) GetRejectedEntities() int64 { + if m != nil { + return m.RejectedEntities + } + return 0 +} + +func (m *ExportEntitiesPartialSuccess) GetErrorMessage() string { + if m != nil { + return m.ErrorMessage + } + return "" +} + +func init() { + proto.RegisterType((*ExportEntitiesServiceRequest)(nil), "opentelemetry.proto.collector.entities.v1.ExportEntitiesServiceRequest") + proto.RegisterType((*ExportEntitiesServiceResponse)(nil), "opentelemetry.proto.collector.entities.v1.ExportEntitiesServiceResponse") + proto.RegisterType((*ExportEntitiesPartialSuccess)(nil), "opentelemetry.proto.collector.entities.v1.ExportEntitiesPartialSuccess") +} + +func init() { + proto.RegisterFile("opentelemetry/proto/collector/entities/v1/entities_service.proto", fileDescriptor_fbd01640b6ae8848) +} + +var fileDescriptor_fbd01640b6ae8848 = []byte{ + // 421 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0xc1, 0xaa, 0xd3, 0x40, + 0x14, 0x86, 0x33, 0xad, 0x14, 0x9c, 0xda, 0x56, 0x43, 0x17, 0xa5, 0x68, 0x2c, 0x71, 0x93, 0xa2, + 0x4c, 0x68, 0x7d, 0x01, 0xa9, 0x14, 0xdd, 0x88, 0x21, 0x55, 0x17, 0x6e, 0x42, 0x4c, 0x0f, 0x21, + 0x92, 0x66, 0xc6, 0x99, 0x69, 0xd0, 0xb7, 0x70, 0xe7, 0xca, 0x17, 0x70, 0xe7, 0x5b, 0x74, 0xd9, + 0xa5, 0x0b, 0x11, 0x69, 0x5f, 0x44, 0x92, 0x31, 0x21, 0x09, 0xb9, 0x50, 0xee, 0xdd, 0xcd, 0x9c, + 0x9c, 0xff, 0xff, 0xfe, 0x9c, 0xe1, 0xe0, 0x67, 0x94, 0x41, 0x22, 0x21, 0x86, 0x1d, 0x48, 0xfe, + 0xc5, 0x66, 0x9c, 0x4a, 0x6a, 0x07, 0x34, 0x8e, 0x21, 0x90, 0x94, 0xdb, 0x90, 0xc8, 0x48, 0x46, + 0x20, 0xec, 0x74, 0x51, 0x9e, 0x3d, 0x01, 0x3c, 0x8d, 0x02, 0x20, 0x79, 0xb3, 0x3e, 0xaf, 0x39, + 0xa8, 0x22, 0x29, 0x1d, 0x48, 0xa1, 0x22, 0xe9, 0x62, 0x3a, 0x0e, 0x69, 0x48, 0x15, 0x22, 0x3b, + 0xa9, 0xde, 0x29, 0x69, 0x8b, 0xd0, 0x06, 0x56, 0xfd, 0xe6, 0x1e, 0xdf, 0x5f, 0x7f, 0x66, 0x94, + 0xcb, 0xf5, 0xff, 0xfa, 0x46, 0xe5, 0x71, 0xe1, 0xd3, 0x1e, 0x84, 0xd4, 0xdf, 0xe2, 0xa1, 0x08, + 0x28, 0x03, 0xaf, 0xd0, 0x4d, 0xd0, 0xac, 0x6b, 0xf5, 0x97, 0x84, 0xb4, 0x25, 0xad, 0xe4, 0x23, + 0x9b, 0x4c, 0x56, 0xb8, 0xba, 0x03, 0x51, 0xbd, 0x9a, 0xdf, 0x10, 0x7e, 0x70, 0x05, 0x57, 0x30, + 0x9a, 0x08, 0xd0, 0x53, 0x3c, 0x62, 0x3e, 0x97, 0x91, 0x1f, 0x7b, 0x62, 0x1f, 0x04, 0x20, 0x32, + 0x32, 0xb2, 0xfa, 0xcb, 0x17, 0xe4, 0xe2, 0x19, 0x91, 0x3a, 0xc2, 0x51, 0x7e, 0x1b, 0x65, 0xb7, + 0xba, 0x75, 0xf8, 0xf3, 0x50, 0x73, 0x87, 0xac, 0x56, 0x35, 0x59, 0x73, 0x20, 0x75, 0x95, 0xfe, + 0x18, 0xdf, 0xe3, 0xf0, 0x11, 0x02, 0x09, 0xdb, 0xea, 0x4c, 0x90, 0xd5, 0x75, 0xef, 0x16, 0x1f, + 0x0a, 0xa9, 0xfe, 0x08, 0x0f, 0x80, 0x73, 0xca, 0xbd, 0x1d, 0x08, 0xe1, 0x87, 0x30, 0xe9, 0xcc, + 0x90, 0x75, 0xdb, 0xbd, 0x93, 0x17, 0x5f, 0xa9, 0xda, 0xf2, 0x27, 0xc2, 0xa3, 0xc6, 0x14, 0xf4, + 0xef, 0x08, 0xf7, 0x54, 0x0c, 0xfd, 0xfa, 0xff, 0x5b, 0x7f, 0xca, 0xe9, 0xcb, 0x9b, 0x1b, 0xa9, + 0xb7, 0x31, 0xb5, 0xd5, 0x6f, 0x74, 0x38, 0x19, 0xe8, 0x78, 0x32, 0xd0, 0xdf, 0x93, 0x81, 0xbe, + 0x9e, 0x0d, 0xed, 0x78, 0x36, 0xb4, 0x5f, 0x67, 0x43, 0xc3, 0x4f, 0x22, 0x7a, 0x39, 0x68, 0x35, + 0x6e, 0x30, 0x9c, 0xac, 0xd7, 0x41, 0xef, 0x9d, 0xb0, 0xe9, 0x12, 0x55, 0x57, 0x89, 0x6d, 0x7d, + 0xe9, 0xdb, 0x51, 0x22, 0x81, 0x27, 0x7e, 0x6c, 0xe7, 0xb7, 0x1c, 0x13, 0x42, 0xd2, 0xbe, 0x71, + 0x3f, 0x3a, 0xf3, 0xd7, 0x0c, 0x92, 0x37, 0xa5, 0x5f, 0x4e, 0x22, 0xcf, 0xcb, 0x54, 0x45, 0x10, + 0xf2, 0x6e, 0xf1, 0xa1, 0x97, 0x7b, 0x3d, 0xfd, 0x17, 0x00, 0x00, 0xff, 0xff, 0x77, 0x76, 0xac, + 0xd8, 0xd1, 0x03, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// EntitiesServiceClient is the client API for EntitiesService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type EntitiesServiceClient interface { + // For performance reasons, it is recommended to keep this RPC + // alive for the entire life of the application. + Export(ctx context.Context, in *ExportEntitiesServiceRequest, opts ...grpc.CallOption) (*ExportEntitiesServiceResponse, error) +} + +type entitiesServiceClient struct { + cc *grpc.ClientConn +} + +func NewEntitiesServiceClient(cc *grpc.ClientConn) EntitiesServiceClient { + return &entitiesServiceClient{cc} +} + +func (c *entitiesServiceClient) Export(ctx context.Context, in *ExportEntitiesServiceRequest, opts ...grpc.CallOption) (*ExportEntitiesServiceResponse, error) { + out := new(ExportEntitiesServiceResponse) + err := c.cc.Invoke(ctx, "/opentelemetry.proto.collector.entities.v1.EntitiesService/Export", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// EntitiesServiceServer is the server API for EntitiesService service. +type EntitiesServiceServer interface { + // For performance reasons, it is recommended to keep this RPC + // alive for the entire life of the application. + Export(context.Context, *ExportEntitiesServiceRequest) (*ExportEntitiesServiceResponse, error) +} + +// UnimplementedEntitiesServiceServer can be embedded to have forward compatible implementations. +type UnimplementedEntitiesServiceServer struct { +} + +func (*UnimplementedEntitiesServiceServer) Export(ctx context.Context, req *ExportEntitiesServiceRequest) (*ExportEntitiesServiceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Export not implemented") +} + +func RegisterEntitiesServiceServer(s *grpc.Server, srv EntitiesServiceServer) { + s.RegisterService(&_EntitiesService_serviceDesc, srv) +} + +func _EntitiesService_Export_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExportEntitiesServiceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EntitiesServiceServer).Export(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/opentelemetry.proto.collector.entities.v1.EntitiesService/Export", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EntitiesServiceServer).Export(ctx, req.(*ExportEntitiesServiceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _EntitiesService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "opentelemetry.proto.collector.entities.v1.EntitiesService", + HandlerType: (*EntitiesServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Export", + Handler: _EntitiesService_Export_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "opentelemetry/proto/collector/entities/v1/entities_service.proto", +} + +func (m *ExportEntitiesServiceRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExportEntitiesServiceRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExportEntitiesServiceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ScopeEntities) > 0 { + for iNdEx := len(m.ScopeEntities) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ScopeEntities[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEntitiesService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ExportEntitiesServiceResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExportEntitiesServiceResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExportEntitiesServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.PartialSuccess.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEntitiesService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ExportEntitiesPartialSuccess) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExportEntitiesPartialSuccess) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExportEntitiesPartialSuccess) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ErrorMessage) > 0 { + i -= len(m.ErrorMessage) + copy(dAtA[i:], m.ErrorMessage) + i = encodeVarintEntitiesService(dAtA, i, uint64(len(m.ErrorMessage))) + i-- + dAtA[i] = 0x12 + } + if m.RejectedEntities != 0 { + i = encodeVarintEntitiesService(dAtA, i, uint64(m.RejectedEntities)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintEntitiesService(dAtA []byte, offset int, v uint64) int { + offset -= sovEntitiesService(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ExportEntitiesServiceRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ScopeEntities) > 0 { + for _, e := range m.ScopeEntities { + l = e.Size() + n += 1 + l + sovEntitiesService(uint64(l)) + } + } + return n +} + +func (m *ExportEntitiesServiceResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.PartialSuccess.Size() + n += 1 + l + sovEntitiesService(uint64(l)) + return n +} + +func (m *ExportEntitiesPartialSuccess) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RejectedEntities != 0 { + n += 1 + sovEntitiesService(uint64(m.RejectedEntities)) + } + l = len(m.ErrorMessage) + if l > 0 { + n += 1 + l + sovEntitiesService(uint64(l)) + } + return n +} + +func sovEntitiesService(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozEntitiesService(x uint64) (n int) { + return sovEntitiesService(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ExportEntitiesServiceRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExportEntitiesServiceRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExportEntitiesServiceRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ScopeEntities", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEntitiesService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEntitiesService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ScopeEntities = append(m.ScopeEntities, &v1.ScopeEntities{}) + if err := m.ScopeEntities[len(m.ScopeEntities)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEntitiesService(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEntitiesService + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExportEntitiesServiceResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExportEntitiesServiceResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExportEntitiesServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PartialSuccess", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEntitiesService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEntitiesService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.PartialSuccess.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEntitiesService(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEntitiesService + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExportEntitiesPartialSuccess) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExportEntitiesPartialSuccess: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExportEntitiesPartialSuccess: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RejectedEntities", wireType) + } + m.RejectedEntities = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RejectedEntities |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ErrorMessage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEntitiesService + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEntitiesService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ErrorMessage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEntitiesService(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEntitiesService + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipEntitiesService(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEntitiesService + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthEntitiesService + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupEntitiesService + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthEntitiesService + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthEntitiesService = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowEntitiesService = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupEntitiesService = fmt.Errorf("proto: unexpected end of group") +) diff --git a/pdata/internal/data/protogen/entities/v1/entities.pb.go b/pdata/internal/data/protogen/entities/v1/entities.pb.go new file mode 100644 index 00000000000..4afbb05c01f --- /dev/null +++ b/pdata/internal/data/protogen/entities/v1/entities.pb.go @@ -0,0 +1,1466 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: opentelemetry/proto/entities/v1/entities.proto + +package v1 + +import ( + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + + v1 "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1" + _ "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// EntitiesData represents the entities data that can be stored in a persistent storage, +// OR can be embedded by other protocols that transfer OTLP entities data but do not +// implement the OTLP protocol. +// +// The main difference between this message and collector protocol is that +// in this message there will not be any "control" or "metadata" specific to +// OTLP protocol. +// +// When new fields are added into this message, the OTLP request MUST be updated +// as well. +type EntitiesData struct { + ScopeEntities []*ScopeEntities `protobuf:"bytes,1,rep,name=scope_entities,json=scopeEntities,proto3" json:"scope_entities,omitempty"` +} + +func (m *EntitiesData) Reset() { *m = EntitiesData{} } +func (m *EntitiesData) String() string { return proto.CompactTextString(m) } +func (*EntitiesData) ProtoMessage() {} +func (*EntitiesData) Descriptor() ([]byte, []int) { + return fileDescriptor_23658fae9436c0cd, []int{0} +} +func (m *EntitiesData) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EntitiesData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EntitiesData.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EntitiesData) XXX_Merge(src proto.Message) { + xxx_messageInfo_EntitiesData.Merge(m, src) +} +func (m *EntitiesData) XXX_Size() int { + return m.Size() +} +func (m *EntitiesData) XXX_DiscardUnknown() { + xxx_messageInfo_EntitiesData.DiscardUnknown(m) +} + +var xxx_messageInfo_EntitiesData proto.InternalMessageInfo + +func (m *EntitiesData) GetScopeEntities() []*ScopeEntities { + if m != nil { + return m.ScopeEntities + } + return nil +} + +// A collection of Entities produced by a Scope. +type ScopeEntities struct { + // The instrumentation scope information for the entities in this message. + // Semantically when InstrumentationScope isn't set, it is equivalent with + // an empty instrumentation scope name (unknown). + Scope v1.InstrumentationScope `protobuf:"bytes,1,opt,name=scope,proto3" json:"scope"` + EntityEvents []*EntityEvent `protobuf:"bytes,2,rep,name=entity_events,json=entityEvents,proto3" json:"entity_events,omitempty"` + // This schema_url applies to all entities in the "entity_events" field. + SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` +} + +func (m *ScopeEntities) Reset() { *m = ScopeEntities{} } +func (m *ScopeEntities) String() string { return proto.CompactTextString(m) } +func (*ScopeEntities) ProtoMessage() {} +func (*ScopeEntities) Descriptor() ([]byte, []int) { + return fileDescriptor_23658fae9436c0cd, []int{1} +} +func (m *ScopeEntities) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScopeEntities) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ScopeEntities.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ScopeEntities) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScopeEntities.Merge(m, src) +} +func (m *ScopeEntities) XXX_Size() int { + return m.Size() +} +func (m *ScopeEntities) XXX_DiscardUnknown() { + xxx_messageInfo_ScopeEntities.DiscardUnknown(m) +} + +var xxx_messageInfo_ScopeEntities proto.InternalMessageInfo + +func (m *ScopeEntities) GetScope() v1.InstrumentationScope { + if m != nil { + return m.Scope + } + return v1.InstrumentationScope{} +} + +func (m *ScopeEntities) GetEntityEvents() []*EntityEvent { + if m != nil { + return m.EntityEvents + } + return nil +} + +func (m *ScopeEntities) GetSchemaUrl() string { + if m != nil { + return m.SchemaUrl + } + return "" +} + +// Entity event, describes something that happened with the entity. +type EntityEvent struct { + // Time when this state was observed. + TimeUnixNano uint64 `protobuf:"varint,1,opt,name=time_unix_nano,json=timeUnixNano,proto3" json:"time_unix_nano,omitempty"` + // Type of the entity, e.g. "service", "host", etc. + EntityType string `protobuf:"bytes,2,opt,name=entity_type,json=entityType,proto3" json:"entity_type,omitempty"` + // Set of attributes that identify the entity. + Id []v1.KeyValue `protobuf:"bytes,3,rep,name=id,proto3" json:"id"` + // One of the following event types must be set. + // + // Types that are valid to be assigned to Data: + // *EntityEvent_EntityState + // *EntityEvent_EntityDelete + Data isEntityEvent_Data `protobuf_oneof:"data"` +} + +func (m *EntityEvent) Reset() { *m = EntityEvent{} } +func (m *EntityEvent) String() string { return proto.CompactTextString(m) } +func (*EntityEvent) ProtoMessage() {} +func (*EntityEvent) Descriptor() ([]byte, []int) { + return fileDescriptor_23658fae9436c0cd, []int{2} +} +func (m *EntityEvent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EntityEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EntityEvent.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EntityEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_EntityEvent.Merge(m, src) +} +func (m *EntityEvent) XXX_Size() int { + return m.Size() +} +func (m *EntityEvent) XXX_DiscardUnknown() { + xxx_messageInfo_EntityEvent.DiscardUnknown(m) +} + +var xxx_messageInfo_EntityEvent proto.InternalMessageInfo + +type isEntityEvent_Data interface { + isEntityEvent_Data() + MarshalTo([]byte) (int, error) + Size() int +} + +type EntityEvent_EntityState struct { + EntityState *EntityState `protobuf:"bytes,4,opt,name=entity_state,json=entityState,proto3,oneof" json:"entity_state,omitempty"` +} +type EntityEvent_EntityDelete struct { + EntityDelete *EntityDelete `protobuf:"bytes,5,opt,name=entity_delete,json=entityDelete,proto3,oneof" json:"entity_delete,omitempty"` +} + +func (*EntityEvent_EntityState) isEntityEvent_Data() {} +func (*EntityEvent_EntityDelete) isEntityEvent_Data() {} + +func (m *EntityEvent) GetData() isEntityEvent_Data { + if m != nil { + return m.Data + } + return nil +} + +func (m *EntityEvent) GetTimeUnixNano() uint64 { + if m != nil { + return m.TimeUnixNano + } + return 0 +} + +func (m *EntityEvent) GetEntityType() string { + if m != nil { + return m.EntityType + } + return "" +} + +func (m *EntityEvent) GetId() []v1.KeyValue { + if m != nil { + return m.Id + } + return nil +} + +func (m *EntityEvent) GetEntityState() *EntityState { + if x, ok := m.GetData().(*EntityEvent_EntityState); ok { + return x.EntityState + } + return nil +} + +func (m *EntityEvent) GetEntityDelete() *EntityDelete { + if x, ok := m.GetData().(*EntityEvent_EntityDelete); ok { + return x.EntityDelete + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*EntityEvent) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*EntityEvent_EntityState)(nil), + (*EntityEvent_EntityDelete)(nil), + } +} + +// The full state of the Entity. +type EntityState struct { + // Set of non-identifying attributes only. + Attributes []v1.KeyValue `protobuf:"bytes,4,rep,name=attributes,proto3" json:"attributes"` + DroppedAttributesCount uint32 `protobuf:"varint,5,opt,name=dropped_attributes_count,json=droppedAttributesCount,proto3" json:"dropped_attributes_count,omitempty"` +} + +func (m *EntityState) Reset() { *m = EntityState{} } +func (m *EntityState) String() string { return proto.CompactTextString(m) } +func (*EntityState) ProtoMessage() {} +func (*EntityState) Descriptor() ([]byte, []int) { + return fileDescriptor_23658fae9436c0cd, []int{3} +} +func (m *EntityState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EntityState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EntityState.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EntityState) XXX_Merge(src proto.Message) { + xxx_messageInfo_EntityState.Merge(m, src) +} +func (m *EntityState) XXX_Size() int { + return m.Size() +} +func (m *EntityState) XXX_DiscardUnknown() { + xxx_messageInfo_EntityState.DiscardUnknown(m) +} + +var xxx_messageInfo_EntityState proto.InternalMessageInfo + +func (m *EntityState) GetAttributes() []v1.KeyValue { + if m != nil { + return m.Attributes + } + return nil +} + +func (m *EntityState) GetDroppedAttributesCount() uint32 { + if m != nil { + return m.DroppedAttributesCount + } + return 0 +} + +// Deletion event. No additional information is recorded. +type EntityDelete struct { +} + +func (m *EntityDelete) Reset() { *m = EntityDelete{} } +func (m *EntityDelete) String() string { return proto.CompactTextString(m) } +func (*EntityDelete) ProtoMessage() {} +func (*EntityDelete) Descriptor() ([]byte, []int) { + return fileDescriptor_23658fae9436c0cd, []int{4} +} +func (m *EntityDelete) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EntityDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EntityDelete.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EntityDelete) XXX_Merge(src proto.Message) { + xxx_messageInfo_EntityDelete.Merge(m, src) +} +func (m *EntityDelete) XXX_Size() int { + return m.Size() +} +func (m *EntityDelete) XXX_DiscardUnknown() { + xxx_messageInfo_EntityDelete.DiscardUnknown(m) +} + +var xxx_messageInfo_EntityDelete proto.InternalMessageInfo + +func init() { + proto.RegisterType((*EntitiesData)(nil), "opentelemetry.proto.entities.v1.EntitiesData") + proto.RegisterType((*ScopeEntities)(nil), "opentelemetry.proto.entities.v1.ScopeEntities") + proto.RegisterType((*EntityEvent)(nil), "opentelemetry.proto.entities.v1.EntityEvent") + proto.RegisterType((*EntityState)(nil), "opentelemetry.proto.entities.v1.EntityState") + proto.RegisterType((*EntityDelete)(nil), "opentelemetry.proto.entities.v1.EntityDelete") +} + +func init() { + proto.RegisterFile("opentelemetry/proto/entities/v1/entities.proto", fileDescriptor_23658fae9436c0cd) +} + +var fileDescriptor_23658fae9436c0cd = []byte{ + // 565 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0xcd, 0x6a, 0xdb, 0x4c, + 0x14, 0x95, 0x14, 0x27, 0x90, 0x71, 0xec, 0x85, 0xf8, 0xf8, 0x10, 0x81, 0xca, 0x46, 0x14, 0x6a, + 0x4a, 0x2b, 0xe1, 0x64, 0xd3, 0x4d, 0x17, 0x75, 0x93, 0x92, 0x52, 0xda, 0x24, 0x8a, 0x9d, 0x45, + 0x37, 0x62, 0x22, 0x5d, 0xdc, 0x01, 0x69, 0x46, 0x48, 0x57, 0x26, 0x7a, 0x8b, 0xae, 0xfa, 0x10, + 0x7d, 0x81, 0xbe, 0x40, 0x17, 0x59, 0x86, 0xae, 0xba, 0x2a, 0xc5, 0x7e, 0x91, 0x32, 0x23, 0xc9, + 0x71, 0x8a, 0xc1, 0xa1, 0xbb, 0xfb, 0x73, 0xee, 0xb9, 0xe7, 0x1e, 0x34, 0x22, 0xae, 0x48, 0x81, + 0x23, 0xc4, 0x90, 0x00, 0x66, 0xa5, 0x97, 0x66, 0x02, 0x85, 0x07, 0x1c, 0x19, 0x32, 0xc8, 0xbd, + 0xd9, 0x70, 0x19, 0xbb, 0xaa, 0x65, 0xf6, 0xee, 0xe1, 0xab, 0xa2, 0xbb, 0xc4, 0xcc, 0x86, 0xfb, + 0xff, 0x4d, 0xc5, 0x54, 0x54, 0x34, 0x32, 0xaa, 0x10, 0xfb, 0x4f, 0xd7, 0xad, 0x09, 0x45, 0x92, + 0x08, 0x2e, 0x97, 0x54, 0x51, 0x8d, 0x5d, 0x2b, 0x29, 0x83, 0x5c, 0x14, 0x59, 0x08, 0x12, 0xdd, + 0xc4, 0x15, 0xde, 0x01, 0xb2, 0x77, 0x5c, 0x0b, 0x38, 0xa2, 0x48, 0xcd, 0x09, 0xe9, 0xe6, 0xa1, + 0x48, 0x21, 0x68, 0x64, 0x59, 0x7a, 0x7f, 0x6b, 0xd0, 0x3e, 0x70, 0xdd, 0x0d, 0xda, 0xdd, 0x0b, + 0x39, 0xd6, 0x70, 0xf9, 0x9d, 0x7c, 0x35, 0x75, 0x7e, 0xe8, 0xa4, 0x73, 0x0f, 0x60, 0x9e, 0x92, + 0x6d, 0x05, 0xb1, 0xf4, 0xbe, 0x3e, 0x68, 0x1f, 0x1c, 0xae, 0xe5, 0xaf, 0x4f, 0x9b, 0x0d, 0xdd, + 0xb7, 0x3c, 0xc7, 0xac, 0x48, 0x80, 0x23, 0x45, 0x26, 0xb8, 0xe2, 0x1a, 0xb5, 0x6e, 0x7e, 0xf5, + 0x34, 0xbf, 0xe2, 0x31, 0xcf, 0x49, 0x47, 0xc9, 0x29, 0x03, 0x98, 0x01, 0xc7, 0xdc, 0x32, 0x94, + 0xf0, 0x67, 0x1b, 0x85, 0x2b, 0x49, 0xe5, 0xb1, 0x1c, 0xf2, 0xf7, 0xe0, 0x2e, 0xc9, 0xcd, 0x47, + 0x84, 0xe4, 0xe1, 0x27, 0x48, 0x68, 0x50, 0x64, 0xb1, 0xb5, 0xd5, 0xd7, 0x07, 0xbb, 0xfe, 0x6e, + 0x55, 0x99, 0x64, 0xb1, 0xf3, 0xdd, 0x20, 0xed, 0x95, 0x61, 0xf3, 0x31, 0xe9, 0x22, 0x4b, 0x20, + 0x28, 0x38, 0xbb, 0x0e, 0x38, 0xe5, 0x42, 0xdd, 0xd6, 0xf2, 0xf7, 0x64, 0x75, 0xc2, 0xd9, 0xf5, + 0x07, 0xca, 0x85, 0xd9, 0x23, 0xed, 0x5a, 0x27, 0x96, 0x29, 0x58, 0x86, 0x62, 0x25, 0x55, 0x69, + 0x5c, 0xa6, 0x60, 0xbe, 0x24, 0x06, 0x8b, 0xac, 0x2d, 0xa5, 0xfe, 0xc9, 0x06, 0x5b, 0xde, 0x41, + 0x79, 0x49, 0xe3, 0xa2, 0xb1, 0xc2, 0x60, 0x91, 0x79, 0x4e, 0xea, 0x23, 0x82, 0x1c, 0x29, 0x82, + 0xd5, 0x52, 0xfe, 0x3e, 0xd4, 0x86, 0x0b, 0x39, 0x73, 0xa2, 0xf9, 0xb5, 0x46, 0x95, 0x9a, 0xe3, + 0xa5, 0xb5, 0x11, 0xc4, 0x80, 0x60, 0x6d, 0x2b, 0xce, 0xe7, 0x0f, 0xe4, 0x3c, 0x52, 0x43, 0x27, + 0x5a, 0xe3, 0x6e, 0x95, 0x8f, 0x76, 0x48, 0x2b, 0xa2, 0x48, 0x9d, 0x2f, 0x7a, 0x63, 0x63, 0xb5, + 0xed, 0x3d, 0x21, 0x14, 0x31, 0x63, 0x57, 0x05, 0x42, 0x6e, 0xb5, 0xfe, 0xc5, 0x87, 0x15, 0x02, + 0xf3, 0x05, 0xb1, 0xa2, 0x4c, 0xa4, 0x29, 0x44, 0xc1, 0x5d, 0x35, 0x08, 0x45, 0xc1, 0x51, 0xdd, + 0xd1, 0xf1, 0xff, 0xaf, 0xfb, 0xaf, 0x96, 0xed, 0xd7, 0xb2, 0xeb, 0x74, 0xeb, 0xb7, 0xd1, 0x08, + 0xfe, 0xa6, 0xdf, 0xcc, 0x6d, 0xfd, 0x76, 0x6e, 0xeb, 0xbf, 0xe7, 0xb6, 0xfe, 0x79, 0x61, 0x6b, + 0xb7, 0x0b, 0x5b, 0xfb, 0xb9, 0xb0, 0x35, 0xe2, 0x30, 0xb1, 0xc9, 0x8c, 0x51, 0xa7, 0xf9, 0xf6, + 0xcf, 0x64, 0xeb, 0x4c, 0xff, 0xf8, 0x66, 0xfa, 0xf7, 0x10, 0x93, 0xef, 0x3a, 0x8e, 0x21, 0x44, + 0x91, 0x79, 0xa9, 0x74, 0xc7, 0x63, 0x1c, 0x21, 0xe3, 0x34, 0xf6, 0x54, 0xa6, 0x58, 0xa7, 0xc0, + 0x57, 0xff, 0x32, 0x5f, 0x8d, 0xde, 0x69, 0x0a, 0x7c, 0xbc, 0x64, 0x51, 0xfc, 0x6e, 0xb3, 0xcd, + 0xbd, 0x1c, 0x5e, 0xed, 0xa8, 0xb9, 0xc3, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf2, 0xcf, 0xcd, + 0xb6, 0xb1, 0x04, 0x00, 0x00, +} + +func (m *EntitiesData) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EntitiesData) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EntitiesData) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ScopeEntities) > 0 { + for iNdEx := len(m.ScopeEntities) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ScopeEntities[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEntities(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ScopeEntities) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ScopeEntities) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ScopeEntities) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.SchemaUrl) > 0 { + i -= len(m.SchemaUrl) + copy(dAtA[i:], m.SchemaUrl) + i = encodeVarintEntities(dAtA, i, uint64(len(m.SchemaUrl))) + i-- + dAtA[i] = 0x1a + } + if len(m.EntityEvents) > 0 { + for iNdEx := len(m.EntityEvents) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.EntityEvents[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEntities(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.Scope.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEntities(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *EntityEvent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EntityEvent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EntityEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Data != nil { + { + size := m.Data.Size() + i -= size + if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + if len(m.Id) > 0 { + for iNdEx := len(m.Id) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Id[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEntities(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.EntityType) > 0 { + i -= len(m.EntityType) + copy(dAtA[i:], m.EntityType) + i = encodeVarintEntities(dAtA, i, uint64(len(m.EntityType))) + i-- + dAtA[i] = 0x12 + } + if m.TimeUnixNano != 0 { + i = encodeVarintEntities(dAtA, i, uint64(m.TimeUnixNano)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EntityEvent_EntityState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EntityEvent_EntityState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EntityState != nil { + { + size, err := m.EntityState.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEntities(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *EntityEvent_EntityDelete) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EntityEvent_EntityDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EntityDelete != nil { + { + size, err := m.EntityDelete.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEntities(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *EntityState) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EntityState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EntityState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DroppedAttributesCount != 0 { + i = encodeVarintEntities(dAtA, i, uint64(m.DroppedAttributesCount)) + i-- + dAtA[i] = 0x28 + } + if len(m.Attributes) > 0 { + for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEntities(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + return len(dAtA) - i, nil +} + +func (m *EntityDelete) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EntityDelete) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EntityDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintEntities(dAtA []byte, offset int, v uint64) int { + offset -= sovEntities(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *EntitiesData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ScopeEntities) > 0 { + for _, e := range m.ScopeEntities { + l = e.Size() + n += 1 + l + sovEntities(uint64(l)) + } + } + return n +} + +func (m *ScopeEntities) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Scope.Size() + n += 1 + l + sovEntities(uint64(l)) + if len(m.EntityEvents) > 0 { + for _, e := range m.EntityEvents { + l = e.Size() + n += 1 + l + sovEntities(uint64(l)) + } + } + l = len(m.SchemaUrl) + if l > 0 { + n += 1 + l + sovEntities(uint64(l)) + } + return n +} + +func (m *EntityEvent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TimeUnixNano != 0 { + n += 1 + sovEntities(uint64(m.TimeUnixNano)) + } + l = len(m.EntityType) + if l > 0 { + n += 1 + l + sovEntities(uint64(l)) + } + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovEntities(uint64(l)) + } + } + if m.Data != nil { + n += m.Data.Size() + } + return n +} + +func (m *EntityEvent_EntityState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EntityState != nil { + l = m.EntityState.Size() + n += 1 + l + sovEntities(uint64(l)) + } + return n +} +func (m *EntityEvent_EntityDelete) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EntityDelete != nil { + l = m.EntityDelete.Size() + n += 1 + l + sovEntities(uint64(l)) + } + return n +} +func (m *EntityState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Attributes) > 0 { + for _, e := range m.Attributes { + l = e.Size() + n += 1 + l + sovEntities(uint64(l)) + } + } + if m.DroppedAttributesCount != 0 { + n += 1 + sovEntities(uint64(m.DroppedAttributesCount)) + } + return n +} + +func (m *EntityDelete) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovEntities(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozEntities(x uint64) (n int) { + return sovEntities(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *EntitiesData) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EntitiesData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EntitiesData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ScopeEntities", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEntities + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEntities + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ScopeEntities = append(m.ScopeEntities, &ScopeEntities{}) + if err := m.ScopeEntities[len(m.ScopeEntities)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEntities(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEntities + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ScopeEntities) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ScopeEntities: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ScopeEntities: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEntities + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEntities + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Scope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EntityEvents", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEntities + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEntities + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EntityEvents = append(m.EntityEvents, &EntityEvent{}) + if err := m.EntityEvents[len(m.EntityEvents)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SchemaUrl", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEntities + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEntities + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SchemaUrl = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEntities(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEntities + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EntityEvent) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EntityEvent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EntityEvent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TimeUnixNano", wireType) + } + m.TimeUnixNano = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TimeUnixNano |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EntityType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEntities + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEntities + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EntityType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEntities + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEntities + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = append(m.Id, v1.KeyValue{}) + if err := m.Id[len(m.Id)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EntityState", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEntities + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEntities + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &EntityState{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &EntityEvent_EntityState{v} + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EntityDelete", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEntities + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEntities + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &EntityDelete{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &EntityEvent_EntityDelete{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEntities(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEntities + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EntityState) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EntityState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EntityState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEntities + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEntities + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Attributes = append(m.Attributes, v1.KeyValue{}) + if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DroppedAttributesCount", wireType) + } + m.DroppedAttributesCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DroppedAttributesCount |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipEntities(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEntities + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EntityDelete) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEntities + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EntityDelete: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EntityDelete: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipEntities(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEntities + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipEntities(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEntities + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEntities + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEntities + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthEntities + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupEntities + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthEntities + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthEntities = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowEntities = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupEntities = fmt.Errorf("proto: unexpected end of group") +) diff --git a/pdata/internal/data/protogen/logs/v1/logs.pb.go b/pdata/internal/data/protogen/logs/v1/logs.pb.go index 65b11fbe286..0902eb75c6c 100644 --- a/pdata/internal/data/protogen/logs/v1/logs.pb.go +++ b/pdata/internal/data/protogen/logs/v1/logs.pb.go @@ -232,6 +232,8 @@ type ResourceLogs struct { // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url // This schema_url applies to the data in the "resource" field. It does not apply // to the data in the "scope_logs" field which have their own schema_url field. + // + // This field is deprecated in favour of Resource.entities.schema_url. SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` } diff --git a/pdata/internal/data/protogen/metrics/v1/metrics.pb.go b/pdata/internal/data/protogen/metrics/v1/metrics.pb.go index 3649bd83f81..d723c63537e 100644 --- a/pdata/internal/data/protogen/metrics/v1/metrics.pb.go +++ b/pdata/internal/data/protogen/metrics/v1/metrics.pb.go @@ -160,6 +160,25 @@ func (DataPointFlags) EnumDescriptor() ([]byte, []int) { // storage, OR can be embedded by other protocols that transfer OTLP metrics // data but do not implement the OTLP protocol. // +// MetricsData +// └─── ResourceMetrics +// +// ├── Resource +// ├── SchemaURL +// └── ScopeMetrics +// ├── Scope +// ├── SchemaURL +// └── Metric +// ├── Name +// ├── Description +// ├── Unit +// └── data +// ├── Gauge +// ├── Sum +// ├── Histogram +// ├── ExponentialHistogram +// └── Summary +// // The main difference between this message and collector protocol is that // in this message there will not be any "control" or "metadata" specific to // OTLP protocol. @@ -228,6 +247,8 @@ type ResourceMetrics struct { // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url // This schema_url applies to the data in the "resource" field. It does not apply // to the data in the "scope_metrics" field which have their own schema_url field. + // + // This field is deprecated in favour of Resource.entities.schema_url. SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` } diff --git a/pdata/internal/data/protogen/resource/v1/resource.pb.go b/pdata/internal/data/protogen/resource/v1/resource.pb.go index d4d1565c764..a71639d183f 100644 --- a/pdata/internal/data/protogen/resource/v1/resource.pb.go +++ b/pdata/internal/data/protogen/resource/v1/resource.pb.go @@ -35,6 +35,8 @@ type Resource struct { // dropped_attributes_count is the number of dropped attributes. If the value is 0, then // no attributes were dropped. DroppedAttributesCount uint32 `protobuf:"varint,2,opt,name=dropped_attributes_count,json=droppedAttributesCount,proto3" json:"dropped_attributes_count,omitempty"` + // Set of entities that participate in this Resource. + Entities []*ResourceEntityRef `protobuf:"bytes,3,rep,name=entities,proto3" json:"entities,omitempty"` } func (m *Resource) Reset() { *m = Resource{} } @@ -84,8 +86,104 @@ func (m *Resource) GetDroppedAttributesCount() uint32 { return 0 } +func (m *Resource) GetEntities() []*ResourceEntityRef { + if m != nil { + return m.Entities + } + return nil +} + +type ResourceEntityRef struct { + // The Schema URL, if known. This is the identifier of the Schema that the entity data + // is recorded in. To learn more about Schema URL see + // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url + // + // This schema_url applies to the data in this message and to the Resource attributes + // referenced by id_attr_keys and descr_attr_keys. + // TODO: discuss if we are happy with this somewhat complicated definition of what + // the schema_url applies to. + // + // This field obsoletes the schema_url field in ResourceMetrics/ResourceSpans/ResourceLogs. + SchemaUrl string `protobuf:"bytes,1,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` + // Defines the type of the entity. MUST not change during the lifetime of the entity. + // For example: "service" or "host". This field is required and MUST not be empty + // for valid entities. + Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` + // Attribute Keys that identify the entity. + // MUST not change during the lifetime of the entity. The Id must contain at least one attribute. + // These keys MUST exist in the containing Resource.attributes. + IdAttrKeys []string `protobuf:"bytes,3,rep,name=id_attr_keys,json=idAttrKeys,proto3" json:"id_attr_keys,omitempty"` + // Descriptive (non-identifying) attribute keys of the entity. + // MAY change over the lifetime of the entity. MAY be empty. + // These attribute keys are not part of entity's identity. + // These keys MUST exist in the containing Resource.attributes. + DescrAttrKeys []string `protobuf:"bytes,4,rep,name=descr_attr_keys,json=descrAttrKeys,proto3" json:"descr_attr_keys,omitempty"` +} + +func (m *ResourceEntityRef) Reset() { *m = ResourceEntityRef{} } +func (m *ResourceEntityRef) String() string { return proto.CompactTextString(m) } +func (*ResourceEntityRef) ProtoMessage() {} +func (*ResourceEntityRef) Descriptor() ([]byte, []int) { + return fileDescriptor_446f73eacf88f3f5, []int{1} +} +func (m *ResourceEntityRef) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResourceEntityRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResourceEntityRef.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ResourceEntityRef) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResourceEntityRef.Merge(m, src) +} +func (m *ResourceEntityRef) XXX_Size() int { + return m.Size() +} +func (m *ResourceEntityRef) XXX_DiscardUnknown() { + xxx_messageInfo_ResourceEntityRef.DiscardUnknown(m) +} + +var xxx_messageInfo_ResourceEntityRef proto.InternalMessageInfo + +func (m *ResourceEntityRef) GetSchemaUrl() string { + if m != nil { + return m.SchemaUrl + } + return "" +} + +func (m *ResourceEntityRef) GetType() string { + if m != nil { + return m.Type + } + return "" +} + +func (m *ResourceEntityRef) GetIdAttrKeys() []string { + if m != nil { + return m.IdAttrKeys + } + return nil +} + +func (m *ResourceEntityRef) GetDescrAttrKeys() []string { + if m != nil { + return m.DescrAttrKeys + } + return nil +} + func init() { proto.RegisterType((*Resource)(nil), "opentelemetry.proto.resource.v1.Resource") + proto.RegisterType((*ResourceEntityRef)(nil), "opentelemetry.proto.resource.v1.ResourceEntityRef") } func init() { @@ -93,26 +191,33 @@ func init() { } var fileDescriptor_446f73eacf88f3f5 = []byte{ - // 302 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xcb, 0x2f, 0x48, 0xcd, - 0x2b, 0x49, 0xcd, 0x49, 0xcd, 0x4d, 0x2d, 0x29, 0xaa, 0xd4, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0xd7, - 0x2f, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5, 0x2f, 0x33, 0x84, 0xb3, 0xf5, 0xc0, 0x52, - 0x42, 0xf2, 0x28, 0xea, 0x21, 0x82, 0x7a, 0x70, 0x35, 0x65, 0x86, 0x52, 0x22, 0xe9, 0xf9, 0xe9, - 0xf9, 0x10, 0x63, 0x40, 0x2c, 0x88, 0x0a, 0x29, 0x2d, 0x6c, 0xd6, 0x24, 0xe7, 0xe7, 0xe6, 0xe6, - 0xe7, 0x81, 0x2c, 0x81, 0xb0, 0x20, 0x6a, 0x95, 0x26, 0x33, 0x72, 0x71, 0x04, 0x41, 0x4d, 0x14, - 0xf2, 0xe5, 0xe2, 0x4a, 0x2c, 0x29, 0x29, 0xca, 0x4c, 0x2a, 0x2d, 0x49, 0x2d, 0x96, 0x60, 0x54, - 0x60, 0xd6, 0xe0, 0x36, 0x52, 0xd7, 0xc3, 0xe6, 0x08, 0xa8, 0x19, 0x65, 0x86, 0x7a, 0xde, 0xa9, - 0x95, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x21, 0x19, 0x20, - 0x64, 0xc1, 0x25, 0x91, 0x52, 0x94, 0x5f, 0x50, 0x90, 0x9a, 0x12, 0x8f, 0x10, 0x8d, 0x4f, 0xce, - 0x2f, 0xcd, 0x2b, 0x91, 0x60, 0x52, 0x60, 0xd4, 0xe0, 0x0d, 0x12, 0x83, 0xca, 0x3b, 0xc2, 0xa5, - 0x9d, 0x41, 0xb2, 0x4e, 0xdb, 0x19, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, - 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x81, - 0x4b, 0x29, 0x33, 0x5f, 0x8f, 0x40, 0xb0, 0x38, 0xf1, 0xc2, 0x7c, 0x14, 0x00, 0x92, 0x0a, 0x60, - 0x8c, 0x72, 0x4b, 0x47, 0xd7, 0x94, 0x09, 0x0a, 0x91, 0x9c, 0x9c, 0xd4, 0xe4, 0x92, 0xfc, 0x22, - 0xfd, 0x82, 0x94, 0xc4, 0x92, 0x44, 0xfd, 0xcc, 0xbc, 0x92, 0xd4, 0xa2, 0xbc, 0xc4, 0x1c, 0x7d, - 0x30, 0x0f, 0x6c, 0x6a, 0x7a, 0x6a, 0x1e, 0x72, 0xfc, 0xac, 0x62, 0x92, 0xf7, 0x2f, 0x48, 0xcd, - 0x0b, 0x81, 0x9b, 0x02, 0x36, 0x5f, 0x0f, 0x66, 0x9b, 0x5e, 0x98, 0x61, 0x12, 0x1b, 0x58, 0x9f, - 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xbd, 0x8b, 0xcf, 0x38, 0xeb, 0x01, 0x00, 0x00, + // 410 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x41, 0x8e, 0xd3, 0x30, + 0x14, 0x86, 0xe3, 0x99, 0x0a, 0x4d, 0x0c, 0x15, 0xc2, 0x42, 0x28, 0x1a, 0x89, 0x34, 0xea, 0x02, + 0x2a, 0x16, 0x8e, 0x32, 0x6c, 0xd8, 0x52, 0x04, 0x9b, 0x11, 0x30, 0xb2, 0x60, 0x16, 0x6c, 0xa2, + 0x34, 0x79, 0x04, 0x8b, 0xc4, 0x8e, 0x1c, 0xa7, 0x52, 0x6e, 0xd1, 0x73, 0x70, 0x01, 0xae, 0xd0, + 0x65, 0x97, 0xac, 0x10, 0x6a, 0x2e, 0x82, 0x62, 0xb7, 0xa1, 0x40, 0xa5, 0xee, 0x5e, 0xde, 0xff, + 0xbf, 0xcf, 0xef, 0x77, 0x8c, 0xa9, 0xac, 0x40, 0x68, 0x28, 0xa0, 0x04, 0xad, 0xda, 0xb0, 0x52, + 0x52, 0xcb, 0x50, 0x41, 0x2d, 0x1b, 0x95, 0x42, 0xb8, 0x8c, 0x86, 0x9a, 0x1a, 0x89, 0x4c, 0xfe, + 0xf2, 0xdb, 0x26, 0x1d, 0x3c, 0xcb, 0xe8, 0xf2, 0x61, 0x2e, 0x73, 0x69, 0x31, 0x7d, 0x65, 0x1d, + 0x97, 0xcf, 0x8e, 0x1d, 0x93, 0xca, 0xb2, 0x94, 0xa2, 0x3f, 0xc4, 0x56, 0xd6, 0x3b, 0xed, 0x10, + 0xbe, 0x60, 0x3b, 0x22, 0x79, 0x8b, 0x71, 0xa2, 0xb5, 0xe2, 0x8b, 0x46, 0x43, 0xed, 0xa1, 0xe0, + 0x7c, 0x76, 0xf7, 0xea, 0x29, 0x3d, 0xb6, 0xc4, 0x8e, 0xb1, 0x8c, 0xe8, 0x35, 0xb4, 0xb7, 0x49, + 0xd1, 0xc0, 0x7c, 0xb4, 0xfe, 0x39, 0x71, 0xd8, 0x01, 0x80, 0xbc, 0xc0, 0x5e, 0xa6, 0x64, 0x55, + 0x41, 0x16, 0xff, 0xe9, 0xc6, 0xa9, 0x6c, 0x84, 0xf6, 0xce, 0x02, 0x34, 0x1b, 0xb3, 0x47, 0x3b, + 0xfd, 0xe5, 0x20, 0xbf, 0xea, 0x55, 0xf2, 0x0e, 0x5f, 0x80, 0xd0, 0x5c, 0x73, 0xa8, 0xbd, 0x73, + 0xb3, 0xc6, 0x15, 0x3d, 0x71, 0x17, 0x74, 0x9f, 0xe2, 0x75, 0x3f, 0xd8, 0x32, 0xf8, 0xcc, 0x06, + 0xc6, 0x74, 0x85, 0xf0, 0x83, 0xff, 0x74, 0xf2, 0x18, 0xe3, 0x3a, 0xfd, 0x02, 0x65, 0x12, 0x37, + 0xaa, 0xf0, 0x50, 0x80, 0x66, 0x2e, 0x73, 0x6d, 0xe7, 0xa3, 0x2a, 0x08, 0xc1, 0x23, 0xdd, 0x56, + 0x60, 0x56, 0x75, 0x99, 0xa9, 0x49, 0x80, 0xef, 0x71, 0x9b, 0x26, 0xfe, 0x0a, 0xad, 0x5d, 0xce, + 0x65, 0x98, 0x9b, 0x04, 0xd7, 0xd0, 0xd6, 0xe4, 0x09, 0xbe, 0x9f, 0x41, 0x9d, 0xaa, 0x03, 0xd3, + 0xc8, 0x98, 0xc6, 0xa6, 0xbd, 0xf7, 0xcd, 0xbf, 0xa3, 0xf5, 0xd6, 0x47, 0x9b, 0xad, 0x8f, 0x7e, + 0x6d, 0x7d, 0xb4, 0xea, 0x7c, 0x67, 0xd3, 0xf9, 0xce, 0x8f, 0xce, 0x77, 0xf0, 0x94, 0xcb, 0x53, + 0x69, 0xe7, 0xe3, 0x7d, 0x9c, 0x9b, 0x5e, 0xba, 0x41, 0x9f, 0xde, 0xe4, 0xff, 0x0e, 0xf1, 0xfe, + 0xa7, 0x17, 0x05, 0xa4, 0x5a, 0xaa, 0xb0, 0xca, 0x12, 0x9d, 0x84, 0x5c, 0x68, 0x50, 0x22, 0x29, + 0x42, 0xf3, 0x65, 0xa8, 0x39, 0x88, 0xc3, 0x27, 0xf8, 0xed, 0x6c, 0xf2, 0xbe, 0x02, 0xf1, 0x61, + 0xa0, 0x18, 0xfe, 0x70, 0xb9, 0xf4, 0x36, 0x5a, 0xdc, 0x31, 0x73, 0xcf, 0x7f, 0x07, 0x00, 0x00, + 0xff, 0xff, 0xbe, 0xbb, 0xb4, 0xae, 0xce, 0x02, 0x00, 0x00, } func (m *Resource) Marshal() (dAtA []byte, err error) { @@ -135,6 +240,20 @@ func (m *Resource) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.Entities) > 0 { + for iNdEx := len(m.Entities) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Entities[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintResource(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } if m.DroppedAttributesCount != 0 { i = encodeVarintResource(dAtA, i, uint64(m.DroppedAttributesCount)) i-- @@ -157,6 +276,61 @@ func (m *Resource) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ResourceEntityRef) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResourceEntityRef) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResourceEntityRef) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.DescrAttrKeys) > 0 { + for iNdEx := len(m.DescrAttrKeys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.DescrAttrKeys[iNdEx]) + copy(dAtA[i:], m.DescrAttrKeys[iNdEx]) + i = encodeVarintResource(dAtA, i, uint64(len(m.DescrAttrKeys[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(m.IdAttrKeys) > 0 { + for iNdEx := len(m.IdAttrKeys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.IdAttrKeys[iNdEx]) + copy(dAtA[i:], m.IdAttrKeys[iNdEx]) + i = encodeVarintResource(dAtA, i, uint64(len(m.IdAttrKeys[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Type) > 0 { + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintResource(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0x12 + } + if len(m.SchemaUrl) > 0 { + i -= len(m.SchemaUrl) + copy(dAtA[i:], m.SchemaUrl) + i = encodeVarintResource(dAtA, i, uint64(len(m.SchemaUrl))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintResource(dAtA []byte, offset int, v uint64) int { offset -= sovResource(v) base := offset @@ -183,6 +357,41 @@ func (m *Resource) Size() (n int) { if m.DroppedAttributesCount != 0 { n += 1 + sovResource(uint64(m.DroppedAttributesCount)) } + if len(m.Entities) > 0 { + for _, e := range m.Entities { + l = e.Size() + n += 1 + l + sovResource(uint64(l)) + } + } + return n +} + +func (m *ResourceEntityRef) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SchemaUrl) + if l > 0 { + n += 1 + l + sovResource(uint64(l)) + } + l = len(m.Type) + if l > 0 { + n += 1 + l + sovResource(uint64(l)) + } + if len(m.IdAttrKeys) > 0 { + for _, s := range m.IdAttrKeys { + l = len(s) + n += 1 + l + sovResource(uint64(l)) + } + } + if len(m.DescrAttrKeys) > 0 { + for _, s := range m.DescrAttrKeys { + l = len(s) + n += 1 + l + sovResource(uint64(l)) + } + } return n } @@ -274,6 +483,218 @@ func (m *Resource) Unmarshal(dAtA []byte) error { break } } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Entities", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResource + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthResource + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthResource + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Entities = append(m.Entities, &ResourceEntityRef{}) + if err := m.Entities[len(m.Entities)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipResource(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthResource + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResourceEntityRef) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResource + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResourceEntityRef: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResourceEntityRef: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SchemaUrl", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResource + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthResource + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthResource + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SchemaUrl = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResource + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthResource + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthResource + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IdAttrKeys", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResource + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthResource + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthResource + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IdAttrKeys = append(m.IdAttrKeys, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DescrAttrKeys", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResource + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthResource + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthResource + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DescrAttrKeys = append(m.DescrAttrKeys, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipResource(dAtA[iNdEx:]) diff --git a/pdata/internal/data/protogen/trace/v1/trace.pb.go b/pdata/internal/data/protogen/trace/v1/trace.pb.go index c1fcf0764e0..8238bdacb3f 100644 --- a/pdata/internal/data/protogen/trace/v1/trace.pb.go +++ b/pdata/internal/data/protogen/trace/v1/trace.pb.go @@ -239,6 +239,8 @@ type ResourceSpans struct { // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url // This schema_url applies to the data in the "resource" field. It does not apply // to the data in the "scope_spans" field which have their own schema_url field. + // + // This field is deprecated in favour of Resource.entities.schema_url. SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` } diff --git a/pdata/internal/generated_wrapper_resource.go b/pdata/internal/generated_wrapper_resource.go index 354b2457ba7..3ab3dd9a6d5 100644 --- a/pdata/internal/generated_wrapper_resource.go +++ b/pdata/internal/generated_wrapper_resource.go @@ -38,4 +38,5 @@ func GenerateTestResource() Resource { func FillTestResource(tv Resource) { FillTestMap(NewMap(&tv.orig.Attributes, tv.state)) tv.orig.DroppedAttributesCount = uint32(17) + FillTestResourceEntityRefSlice(NewResourceEntityRefSlice(&tv.orig.Entities, tv.state)) } diff --git a/pdata/internal/generated_wrapper_resourceentityref.go b/pdata/internal/generated_wrapper_resourceentityref.go new file mode 100644 index 00000000000..35025fc1c3d --- /dev/null +++ b/pdata/internal/generated_wrapper_resourceentityref.go @@ -0,0 +1,43 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1" +) + +type ResourceEntityRef struct { + orig *otlpresource.ResourceEntityRef + state *State +} + +func GetOrigResourceEntityRef(ms ResourceEntityRef) *otlpresource.ResourceEntityRef { + return ms.orig +} + +func GetResourceEntityRefState(ms ResourceEntityRef) *State { + return ms.state +} + +func NewResourceEntityRef(orig *otlpresource.ResourceEntityRef, state *State) ResourceEntityRef { + return ResourceEntityRef{orig: orig, state: state} +} + +func GenerateTestResourceEntityRef() ResourceEntityRef { + orig := otlpresource.ResourceEntityRef{} + state := StateMutable + tv := NewResourceEntityRef(&orig, &state) + FillTestResourceEntityRef(tv) + return tv +} + +func FillTestResourceEntityRef(tv ResourceEntityRef) { + tv.orig.SchemaUrl = "https://opentelemetry.io/schemas/1.5.0" + tv.orig.Type = "host" + FillTestStringSlice(NewStringSlice(&tv.orig.IdAttrKeys, tv.state)) + FillTestStringSlice(NewStringSlice(&tv.orig.DescrAttrKeys, tv.state)) +} diff --git a/pdata/internal/generated_wrapper_resourceentityrefslice.go b/pdata/internal/generated_wrapper_resourceentityrefslice.go new file mode 100644 index 00000000000..aee0cb000ca --- /dev/null +++ b/pdata/internal/generated_wrapper_resourceentityrefslice.go @@ -0,0 +1,44 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1" +) + +type ResourceEntityRefSlice struct { + orig *[]*otlpresource.ResourceEntityRef + state *State +} + +func GetOrigResourceEntityRefSlice(ms ResourceEntityRefSlice) *[]*otlpresource.ResourceEntityRef { + return ms.orig +} + +func GetResourceEntityRefSliceState(ms ResourceEntityRefSlice) *State { + return ms.state +} + +func NewResourceEntityRefSlice(orig *[]*otlpresource.ResourceEntityRef, state *State) ResourceEntityRefSlice { + return ResourceEntityRefSlice{orig: orig, state: state} +} + +func GenerateTestResourceEntityRefSlice() ResourceEntityRefSlice { + orig := []*otlpresource.ResourceEntityRef(nil) + state := StateMutable + es := NewResourceEntityRefSlice(&orig, &state) + FillTestResourceEntityRefSlice(es) + return es +} + +func FillTestResourceEntityRefSlice(es ResourceEntityRefSlice) { + *es.orig = make([]*otlpresource.ResourceEntityRef, 7) + for i := 0; i < 7; i++ { + (*es.orig)[i] = &otlpresource.ResourceEntityRef{} + FillTestResourceEntityRef(NewResourceEntityRef((*es.orig)[i], es.state)) + } +} diff --git a/pdata/internal/wrapper_entities.go b/pdata/internal/wrapper_entities.go new file mode 100644 index 00000000000..ab54f9f36f1 --- /dev/null +++ b/pdata/internal/wrapper_entities.go @@ -0,0 +1,46 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package internal // import "go.opentelemetry.io/collector/pdata/internal" + +import ( + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/entities/v1" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +type Entities struct { + orig *otlpcollectorlog.ExportEntitiesServiceRequest + state *State +} + +func GetOrigEntities(ms Entities) *otlpcollectorlog.ExportEntitiesServiceRequest { + return ms.orig +} + +func GetEntitiesState(ms Entities) *State { + return ms.state +} + +func SetEntitiesState(ms Entities, state State) { + *ms.state = state +} + +func NewEntities(orig *otlpcollectorlog.ExportEntitiesServiceRequest, state *State) Entities { + return Entities{orig: orig, state: state} +} + +// EntitiesToProto internal helper to convert Entities to protobuf representation. +func EntitiesToProto(l Entities) otlpentities.EntitiesData { + return otlpentities.EntitiesData{ + ScopeEntities: l.orig.ScopeEntities, + } +} + +// EntitiesFromProto internal helper to convert protobuf representation to Entities. +// This function set exclusive state assuming that it's called only once per Entities. +func EntitiesFromProto(orig otlpentities.EntitiesData) Entities { + state := StateMutable + return NewEntities(&otlpcollectorlog.ExportEntitiesServiceRequest{ + ScopeEntities: orig.ScopeEntities, + }, &state) +} diff --git a/pdata/pcommon/generated_resource.go b/pdata/pcommon/generated_resource.go index 12e6cfa7f3b..0455a115664 100644 --- a/pdata/pcommon/generated_resource.go +++ b/pdata/pcommon/generated_resource.go @@ -66,9 +66,15 @@ func (ms Resource) SetDroppedAttributesCount(v uint32) { ms.getOrig().DroppedAttributesCount = v } +// Entities returns the Entities associated with this Resource. +func (ms Resource) Entities() ResourceEntityRefSlice { + return ResourceEntityRefSlice(internal.NewResourceEntityRefSlice(&ms.getOrig().Entities, internal.GetResourceState(internal.Resource(ms)))) +} + // CopyTo copies all properties from the current struct overriding the destination. func (ms Resource) CopyTo(dest Resource) { dest.getState().AssertMutable() ms.Attributes().CopyTo(dest.Attributes()) dest.SetDroppedAttributesCount(ms.DroppedAttributesCount()) + ms.Entities().CopyTo(dest.Entities()) } diff --git a/pdata/pcommon/generated_resource_test.go b/pdata/pcommon/generated_resource_test.go index a7af5300fe8..1e89a22c4e5 100644 --- a/pdata/pcommon/generated_resource_test.go +++ b/pdata/pcommon/generated_resource_test.go @@ -53,3 +53,10 @@ func TestResource_DroppedAttributesCount(t *testing.T) { sharedState := internal.StateReadOnly assert.Panics(t, func() { newResource(&otlpresource.Resource{}, &sharedState).SetDroppedAttributesCount(uint32(17)) }) } + +func TestResource_Entities(t *testing.T) { + ms := NewResource() + assert.Equal(t, NewResourceEntityRefSlice(), ms.Entities()) + internal.FillTestResourceEntityRefSlice(internal.ResourceEntityRefSlice(ms.Entities())) + assert.Equal(t, ResourceEntityRefSlice(internal.GenerateTestResourceEntityRefSlice()), ms.Entities()) +} diff --git a/pdata/pcommon/generated_resourceentityref.go b/pdata/pcommon/generated_resourceentityref.go new file mode 100644 index 00000000000..0cffa0f4f8b --- /dev/null +++ b/pdata/pcommon/generated_resourceentityref.go @@ -0,0 +1,90 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pcommon + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1" +) + +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewResourceEntityRef function to create new instances. +// Important: zero-initialized instance is not valid for use. +type ResourceEntityRef internal.ResourceEntityRef + +func newResourceEntityRef(orig *otlpresource.ResourceEntityRef, state *internal.State) ResourceEntityRef { + return ResourceEntityRef(internal.NewResourceEntityRef(orig, state)) +} + +// NewResourceEntityRef creates a new empty ResourceEntityRef. +// +// 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 NewResourceEntityRef() ResourceEntityRef { + state := internal.StateMutable + return newResourceEntityRef(&otlpresource.ResourceEntityRef{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms ResourceEntityRef) MoveTo(dest ResourceEntityRef) { + ms.getState().AssertMutable() + dest.getState().AssertMutable() + *dest.getOrig() = *ms.getOrig() + *ms.getOrig() = otlpresource.ResourceEntityRef{} +} + +func (ms ResourceEntityRef) getOrig() *otlpresource.ResourceEntityRef { + return internal.GetOrigResourceEntityRef(internal.ResourceEntityRef(ms)) +} + +func (ms ResourceEntityRef) getState() *internal.State { + return internal.GetResourceEntityRefState(internal.ResourceEntityRef(ms)) +} + +// SchemaUrl returns the schemaurl associated with this ResourceEntityRef. +func (ms ResourceEntityRef) SchemaUrl() string { + return ms.getOrig().SchemaUrl +} + +// SetSchemaUrl replaces the schemaurl associated with this ResourceEntityRef. +func (ms ResourceEntityRef) SetSchemaUrl(v string) { + ms.getState().AssertMutable() + ms.getOrig().SchemaUrl = v +} + +// Type returns the type associated with this ResourceEntityRef. +func (ms ResourceEntityRef) Type() string { + return ms.getOrig().Type +} + +// SetType replaces the type associated with this ResourceEntityRef. +func (ms ResourceEntityRef) SetType(v string) { + ms.getState().AssertMutable() + ms.getOrig().Type = v +} + +// IdAttrKeys returns the IdAttrKeys associated with this ResourceEntityRef. +func (ms ResourceEntityRef) IdAttrKeys() StringSlice { + return StringSlice(internal.NewStringSlice(&ms.getOrig().IdAttrKeys, internal.GetResourceEntityRefState(internal.ResourceEntityRef(ms)))) +} + +// DescrAttrKeys returns the DescrAttrKeys associated with this ResourceEntityRef. +func (ms ResourceEntityRef) DescrAttrKeys() StringSlice { + return StringSlice(internal.NewStringSlice(&ms.getOrig().DescrAttrKeys, internal.GetResourceEntityRefState(internal.ResourceEntityRef(ms)))) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms ResourceEntityRef) CopyTo(dest ResourceEntityRef) { + dest.getState().AssertMutable() + dest.SetSchemaUrl(ms.SchemaUrl()) + dest.SetType(ms.Type()) + ms.IdAttrKeys().CopyTo(dest.IdAttrKeys()) + ms.DescrAttrKeys().CopyTo(dest.DescrAttrKeys()) +} diff --git a/pdata/pcommon/generated_resourceentityref_test.go b/pdata/pcommon/generated_resourceentityref_test.go new file mode 100644 index 00000000000..fe90f8279f8 --- /dev/null +++ b/pdata/pcommon/generated_resourceentityref_test.go @@ -0,0 +1,73 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pcommon + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1" +) + +func TestResourceEntityRef_MoveTo(t *testing.T) { + ms := ResourceEntityRef(internal.GenerateTestResourceEntityRef()) + dest := NewResourceEntityRef() + ms.MoveTo(dest) + assert.Equal(t, NewResourceEntityRef(), ms) + assert.Equal(t, ResourceEntityRef(internal.GenerateTestResourceEntityRef()), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newResourceEntityRef(&otlpresource.ResourceEntityRef{}, &sharedState)) }) + assert.Panics(t, func() { newResourceEntityRef(&otlpresource.ResourceEntityRef{}, &sharedState).MoveTo(dest) }) +} + +func TestResourceEntityRef_CopyTo(t *testing.T) { + ms := NewResourceEntityRef() + orig := NewResourceEntityRef() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = ResourceEntityRef(internal.GenerateTestResourceEntityRef()) + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newResourceEntityRef(&otlpresource.ResourceEntityRef{}, &sharedState)) }) +} + +func TestResourceEntityRef_SchemaUrl(t *testing.T) { + ms := NewResourceEntityRef() + assert.Equal(t, "", ms.SchemaUrl()) + ms.SetSchemaUrl("https://opentelemetry.io/schemas/1.5.0") + assert.Equal(t, "https://opentelemetry.io/schemas/1.5.0", ms.SchemaUrl()) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + newResourceEntityRef(&otlpresource.ResourceEntityRef{}, &sharedState).SetSchemaUrl("https://opentelemetry.io/schemas/1.5.0") + }) +} + +func TestResourceEntityRef_Type(t *testing.T) { + ms := NewResourceEntityRef() + assert.Equal(t, "", ms.Type()) + ms.SetType("host") + assert.Equal(t, "host", ms.Type()) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { newResourceEntityRef(&otlpresource.ResourceEntityRef{}, &sharedState).SetType("host") }) +} + +func TestResourceEntityRef_IdAttrKeys(t *testing.T) { + ms := NewResourceEntityRef() + assert.Equal(t, NewStringSlice(), ms.IdAttrKeys()) + internal.FillTestStringSlice(internal.StringSlice(ms.IdAttrKeys())) + assert.Equal(t, StringSlice(internal.GenerateTestStringSlice()), ms.IdAttrKeys()) +} + +func TestResourceEntityRef_DescrAttrKeys(t *testing.T) { + ms := NewResourceEntityRef() + assert.Equal(t, NewStringSlice(), ms.DescrAttrKeys()) + internal.FillTestStringSlice(internal.StringSlice(ms.DescrAttrKeys())) + assert.Equal(t, StringSlice(internal.GenerateTestStringSlice()), ms.DescrAttrKeys()) +} diff --git a/pdata/pcommon/generated_resourceentityrefslice.go b/pdata/pcommon/generated_resourceentityrefslice.go new file mode 100644 index 00000000000..7df85ac26bb --- /dev/null +++ b/pdata/pcommon/generated_resourceentityrefslice.go @@ -0,0 +1,157 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pcommon + +import ( + "sort" + + "go.opentelemetry.io/collector/pdata/internal" + otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1" +) + +// ResourceEntityRefSlice logically represents a slice of ResourceEntityRef. +// +// This is a reference type. If passed by value and callee modifies it, the +// caller will see the modification. +// +// Must use NewResourceEntityRefSlice function to create new instances. +// Important: zero-initialized instance is not valid for use. +type ResourceEntityRefSlice internal.ResourceEntityRefSlice + +func newResourceEntityRefSlice(orig *[]*otlpresource.ResourceEntityRef, state *internal.State) ResourceEntityRefSlice { + return ResourceEntityRefSlice(internal.NewResourceEntityRefSlice(orig, state)) +} + +func (ms ResourceEntityRefSlice) getOrig() *[]*otlpresource.ResourceEntityRef { + return internal.GetOrigResourceEntityRefSlice(internal.ResourceEntityRefSlice(ms)) +} + +func (ms ResourceEntityRefSlice) getState() *internal.State { + return internal.GetResourceEntityRefSliceState(internal.ResourceEntityRefSlice(ms)) +} + +// NewResourceEntityRefSlice creates a ResourceEntityRefSlice with 0 elements. +// Can use "EnsureCapacity" to initialize with a given capacity. +func NewResourceEntityRefSlice() ResourceEntityRefSlice { + orig := []*otlpresource.ResourceEntityRef(nil) + state := internal.StateMutable + return newResourceEntityRefSlice(&orig, &state) +} + +// Len returns the number of elements in the slice. +// +// Returns "0" for a newly instance created with "NewResourceEntityRefSlice()". +func (es ResourceEntityRefSlice) Len() int { + return len(*es.getOrig()) +} + +// At returns the element at the given index. +// +// This function is used mostly for iterating over all the values in the slice: +// +// for i := 0; i < es.Len(); i++ { +// e := es.At(i) +// ... // Do something with the element +// } +func (es ResourceEntityRefSlice) At(i int) ResourceEntityRef { + return ResourceEntityRef(internal.NewResourceEntityRef((*es.getOrig())[i], es.getState())) +} + +// EnsureCapacity is an operation that ensures the slice has at least the specified capacity. +// 1. If the newCap <= cap then no change in capacity. +// 2. If the newCap > cap then the slice capacity will be expanded to equal newCap. +// +// Here is how a new ResourceEntityRefSlice can be initialized: +// +// es := NewResourceEntityRefSlice() +// es.EnsureCapacity(4) +// for i := 0; i < 4; i++ { +// e := es.AppendEmpty() +// // Here should set all the values for e. +// } +func (es ResourceEntityRefSlice) EnsureCapacity(newCap int) { + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) + if newCap <= oldCap { + return + } + + newOrig := make([]*otlpresource.ResourceEntityRef, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig +} + +// AppendEmpty will append to the end of the slice an empty ResourceEntityRef. +// It returns the newly added ResourceEntityRef. +func (es ResourceEntityRefSlice) AppendEmpty() ResourceEntityRef { + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpresource.ResourceEntityRef{}) + return es.At(es.Len() - 1) +} + +// MoveAndAppendTo moves all elements from the current slice and appends them to the dest. +// The current slice will be cleared. +func (es ResourceEntityRefSlice) MoveAndAppendTo(dest ResourceEntityRefSlice) { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { + // We can simply move the entire vector and avoid any allocations. + *dest.getOrig() = *es.getOrig() + } else { + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) + } + *es.getOrig() = nil +} + +// RemoveIf calls f sequentially for each element present in the slice. +// If f returns true, the element is removed from the slice. +func (es ResourceEntityRefSlice) RemoveIf(f func(ResourceEntityRef) bool) { + es.getState().AssertMutable() + newLen := 0 + for i := 0; i < len(*es.getOrig()); i++ { + if f(es.At(i)) { + continue + } + if newLen == i { + // Nothing to move, element is at the right place. + newLen++ + continue + } + (*es.getOrig())[newLen] = (*es.getOrig())[i] + newLen++ + } + *es.getOrig() = (*es.getOrig())[:newLen] +} + +// CopyTo copies all elements from the current slice overriding the destination. +func (es ResourceEntityRefSlice) CopyTo(dest ResourceEntityRefSlice) { + dest.getState().AssertMutable() + srcLen := es.Len() + destCap := cap(*dest.getOrig()) + if srcLen <= destCap { + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newResourceEntityRef((*es.getOrig())[i], es.getState()).CopyTo(newResourceEntityRef((*dest.getOrig())[i], dest.getState())) + } + return + } + origs := make([]otlpresource.ResourceEntityRef, srcLen) + wrappers := make([]*otlpresource.ResourceEntityRef, srcLen) + for i := range *es.getOrig() { + wrappers[i] = &origs[i] + newResourceEntityRef((*es.getOrig())[i], es.getState()).CopyTo(newResourceEntityRef(wrappers[i], dest.getState())) + } + *dest.getOrig() = wrappers +} + +// Sort sorts the ResourceEntityRef elements within ResourceEntityRefSlice given the +// provided less function so that two instances of ResourceEntityRefSlice +// can be compared. +func (es ResourceEntityRefSlice) Sort(less func(a, b ResourceEntityRef) bool) { + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) +} diff --git a/pdata/pcommon/generated_resourceentityrefslice_test.go b/pdata/pcommon/generated_resourceentityrefslice_test.go new file mode 100644 index 00000000000..7e465d69a46 --- /dev/null +++ b/pdata/pcommon/generated_resourceentityrefslice_test.go @@ -0,0 +1,143 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pcommon + +import ( + "testing" + "unsafe" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1" +) + +func TestResourceEntityRefSlice(t *testing.T) { + es := NewResourceEntityRefSlice() + assert.Equal(t, 0, es.Len()) + state := internal.StateMutable + es = newResourceEntityRefSlice(&[]*otlpresource.ResourceEntityRef{}, &state) + assert.Equal(t, 0, es.Len()) + + emptyVal := NewResourceEntityRef() + testVal := ResourceEntityRef(internal.GenerateTestResourceEntityRef()) + for i := 0; i < 7; i++ { + el := es.AppendEmpty() + assert.Equal(t, emptyVal, es.At(i)) + internal.FillTestResourceEntityRef(internal.ResourceEntityRef(el)) + assert.Equal(t, testVal, es.At(i)) + } + assert.Equal(t, 7, es.Len()) +} + +func TestResourceEntityRefSliceReadOnly(t *testing.T) { + sharedState := internal.StateReadOnly + es := newResourceEntityRefSlice(&[]*otlpresource.ResourceEntityRef{}, &sharedState) + assert.Equal(t, 0, es.Len()) + assert.Panics(t, func() { es.AppendEmpty() }) + assert.Panics(t, func() { es.EnsureCapacity(2) }) + es2 := NewResourceEntityRefSlice() + es.CopyTo(es2) + assert.Panics(t, func() { es2.CopyTo(es) }) + assert.Panics(t, func() { es.MoveAndAppendTo(es2) }) + assert.Panics(t, func() { es2.MoveAndAppendTo(es) }) +} + +func TestResourceEntityRefSlice_CopyTo(t *testing.T) { + dest := NewResourceEntityRefSlice() + // Test CopyTo to empty + NewResourceEntityRefSlice().CopyTo(dest) + assert.Equal(t, NewResourceEntityRefSlice(), dest) + + // Test CopyTo larger slice + generateTestResourceEntityRefSlice().CopyTo(dest) + assert.Equal(t, generateTestResourceEntityRefSlice(), dest) + + // Test CopyTo same size slice + generateTestResourceEntityRefSlice().CopyTo(dest) + assert.Equal(t, generateTestResourceEntityRefSlice(), dest) +} + +func TestResourceEntityRefSlice_EnsureCapacity(t *testing.T) { + es := generateTestResourceEntityRefSlice() + + // Test ensure smaller capacity. + const ensureSmallLen = 4 + es.EnsureCapacity(ensureSmallLen) + assert.Less(t, ensureSmallLen, es.Len()) + assert.Equal(t, es.Len(), cap(*es.getOrig())) + assert.Equal(t, generateTestResourceEntityRefSlice(), es) + + // Test ensure larger capacity + const ensureLargeLen = 9 + es.EnsureCapacity(ensureLargeLen) + assert.Less(t, generateTestResourceEntityRefSlice().Len(), ensureLargeLen) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) + assert.Equal(t, generateTestResourceEntityRefSlice(), es) +} + +func TestResourceEntityRefSlice_MoveAndAppendTo(t *testing.T) { + // Test MoveAndAppendTo to empty + expectedSlice := generateTestResourceEntityRefSlice() + dest := NewResourceEntityRefSlice() + src := generateTestResourceEntityRefSlice() + src.MoveAndAppendTo(dest) + assert.Equal(t, generateTestResourceEntityRefSlice(), dest) + assert.Equal(t, 0, src.Len()) + assert.Equal(t, expectedSlice.Len(), dest.Len()) + + // Test MoveAndAppendTo empty slice + src.MoveAndAppendTo(dest) + assert.Equal(t, generateTestResourceEntityRefSlice(), dest) + assert.Equal(t, 0, src.Len()) + assert.Equal(t, expectedSlice.Len(), dest.Len()) + + // Test MoveAndAppendTo not empty slice + generateTestResourceEntityRefSlice().MoveAndAppendTo(dest) + assert.Equal(t, 2*expectedSlice.Len(), dest.Len()) + for i := 0; i < expectedSlice.Len(); i++ { + assert.Equal(t, expectedSlice.At(i), dest.At(i)) + assert.Equal(t, expectedSlice.At(i), dest.At(i+expectedSlice.Len())) + } +} + +func TestResourceEntityRefSlice_RemoveIf(t *testing.T) { + // Test RemoveIf on empty slice + emptySlice := NewResourceEntityRefSlice() + emptySlice.RemoveIf(func(el ResourceEntityRef) bool { + t.Fail() + return false + }) + + // Test RemoveIf + filtered := generateTestResourceEntityRefSlice() + pos := 0 + filtered.RemoveIf(func(el ResourceEntityRef) bool { + pos++ + return pos%3 == 0 + }) + assert.Equal(t, 5, filtered.Len()) +} + +func TestResourceEntityRefSlice_Sort(t *testing.T) { + es := generateTestResourceEntityRefSlice() + es.Sort(func(a, b ResourceEntityRef) bool { + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) + }) + for i := 1; i < es.Len(); i++ { + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) + } + es.Sort(func(a, b ResourceEntityRef) bool { + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) + }) + for i := 1; i < es.Len(); i++ { + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) + } +} +func generateTestResourceEntityRefSlice() ResourceEntityRefSlice { + return ResourceEntityRefSlice(internal.GenerateTestResourceEntityRefSlice()) +} diff --git a/pdata/pentity/entities.go b/pdata/pentity/entities.go new file mode 100644 index 00000000000..fbb41bd36f0 --- /dev/null +++ b/pdata/pentity/entities.go @@ -0,0 +1,62 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package pentity // import "go.opentelemetry.io/collector/pdata/pentity" + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/entities/v1" +) + +// Entities is the top-level struct that is propagated through the entities pipeline. +// Use NewEntities to create new instance, zero-initialized instance is not valid for use. +type Entities internal.Entities + +func newEntities(orig *otlpcollectorlog.ExportEntitiesServiceRequest) Entities { + state := internal.StateMutable + return Entities(internal.NewEntities(orig, &state)) +} + +func (ms Entities) getOrig() *otlpcollectorlog.ExportEntitiesServiceRequest { + return internal.GetOrigEntities(internal.Entities(ms)) +} + +func (ms Entities) getState() *internal.State { + return internal.GetEntitiesState(internal.Entities(ms)) +} + +// NewEntities creates a new Entities struct. +func NewEntities() Entities { + return newEntities(&otlpcollectorlog.ExportEntitiesServiceRequest{}) +} + +// IsReadOnly returns true if this Entities instance is read-only. +func (ms Entities) IsReadOnly() bool { + return *ms.getState() == internal.StateReadOnly +} + +// CopyTo copies the Entities instance overriding the destination. +func (ms Entities) CopyTo(dest Entities) { + ms.ScopeEntities().CopyTo(dest.ScopeEntities()) +} + +// LogRecordCount calculates the total number of log records. +func (ms Entities) LogRecordCount() int { + logCount := 0 + ill := ms.ScopeEntities() + for i := 0; i < ill.Len(); i++ { + entities := ill.At(i) + logCount += entities.EntityEvents().Len() + } + return logCount +} + +// ScopeEntities returns the ScopeEntitiesSlice associated with this Entities. +func (ms Entities) ScopeEntities() ScopeEntitiesSlice { + return newScopeEntitiesSlice(&ms.getOrig().ScopeEntities, internal.GetEntitiesState(internal.Entities(ms))) +} + +// MarkReadOnly marks the Entities as shared so that no further modifications can be done on it. +func (ms Entities) MarkReadOnly() { + internal.SetEntitiesState(internal.Entities(ms), internal.StateReadOnly) +} diff --git a/pdata/pentity/event_type.go b/pdata/pentity/event_type.go new file mode 100644 index 00000000000..8e5d3268ea9 --- /dev/null +++ b/pdata/pentity/event_type.go @@ -0,0 +1,27 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package pentity // import "go.opentelemetry.io/collector/pdata/pentity" + +// EventType specifies the type of entity event. +type EventType int32 + +const ( + // EventTypeEmpty means that metric type is unset. + EventTypeEmpty EventType = iota + EventTypeEntityState + EventTypeEntityDelete +) + +// String returns the string representation of the EventType. +func (mdt EventType) String() string { + switch mdt { + case EventTypeEmpty: + return "Empty" + case EventTypeEntityState: + return "State" + case EventTypeEntityDelete: + return "Delete" + } + return "" +} diff --git a/pdata/pentity/generated_entitydelete.go b/pdata/pentity/generated_entitydelete.go new file mode 100644 index 00000000000..5613849ddbf --- /dev/null +++ b/pdata/pentity/generated_entitydelete.go @@ -0,0 +1,59 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +// EntityDelete are experimental implementation of OpenTelemetry Entity Data Model. + +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewEntityDelete function to create new instances. +// Important: zero-initialized instance is not valid for use. +type EntityDelete struct { + orig *otlpentities.EntityDelete + state *internal.State +} + +func newEntityDelete(orig *otlpentities.EntityDelete, state *internal.State) EntityDelete { + return EntityDelete{orig: orig, state: state} +} + +// NewEntityDelete creates a new empty EntityDelete. +// +// 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 NewEntityDelete() EntityDelete { + state := internal.StateMutable + return newEntityDelete(&otlpentities.EntityDelete{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms EntityDelete) MoveTo(dest EntityDelete) { + ms.state.AssertMutable() + dest.state.AssertMutable() + *dest.orig = *ms.orig + *ms.orig = otlpentities.EntityDelete{} +} + +func (ms EntityDelete) getOrig() *otlpentities.EntityDelete { + return ms.orig +} + +func (ms EntityDelete) getState() *internal.State { + return ms.state +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms EntityDelete) CopyTo(dest EntityDelete) { + dest.state.AssertMutable() +} diff --git a/pdata/pentity/generated_entitydelete_test.go b/pdata/pentity/generated_entitydelete_test.go new file mode 100644 index 00000000000..7fe04c748a4 --- /dev/null +++ b/pdata/pentity/generated_entitydelete_test.go @@ -0,0 +1,48 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +func TestEntityDelete_MoveTo(t *testing.T) { + ms := generateTestEntityDelete() + dest := NewEntityDelete() + ms.MoveTo(dest) + assert.Equal(t, NewEntityDelete(), ms) + assert.Equal(t, generateTestEntityDelete(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newEntityDelete(&otlpentities.EntityDelete{}, &sharedState)) }) + assert.Panics(t, func() { newEntityDelete(&otlpentities.EntityDelete{}, &sharedState).MoveTo(dest) }) +} + +func TestEntityDelete_CopyTo(t *testing.T) { + ms := NewEntityDelete() + orig := NewEntityDelete() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestEntityDelete() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newEntityDelete(&otlpentities.EntityDelete{}, &sharedState)) }) +} + +func generateTestEntityDelete() EntityDelete { + tv := NewEntityDelete() + fillTestEntityDelete(tv) + return tv +} + +func fillTestEntityDelete(tv EntityDelete) { +} diff --git a/pdata/pentity/generated_entityevent.go b/pdata/pentity/generated_entityevent.go new file mode 100644 index 00000000000..d2c2546901b --- /dev/null +++ b/pdata/pentity/generated_entityevent.go @@ -0,0 +1,161 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" + "go.opentelemetry.io/collector/pdata/pcommon" +) + +// EntityEvent are experimental implementation of OpenTelemetry Entity Data Model. + +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewEntityEvent function to create new instances. +// Important: zero-initialized instance is not valid for use. +type EntityEvent struct { + orig *otlpentities.EntityEvent + state *internal.State +} + +func newEntityEvent(orig *otlpentities.EntityEvent, state *internal.State) EntityEvent { + return EntityEvent{orig: orig, state: state} +} + +// NewEntityEvent creates a new empty EntityEvent. +// +// 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 NewEntityEvent() EntityEvent { + state := internal.StateMutable + return newEntityEvent(&otlpentities.EntityEvent{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms EntityEvent) MoveTo(dest EntityEvent) { + ms.state.AssertMutable() + dest.state.AssertMutable() + *dest.orig = *ms.orig + *ms.orig = otlpentities.EntityEvent{} +} + +func (ms EntityEvent) getOrig() *otlpentities.EntityEvent { + return ms.orig +} + +func (ms EntityEvent) getState() *internal.State { + return ms.state +} + +// Timestamp returns the timestamp associated with this EntityEvent. +func (ms EntityEvent) Timestamp() pcommon.Timestamp { + return pcommon.Timestamp(ms.orig.TimeUnixNano) +} + +// SetTimestamp replaces the timestamp associated with this EntityEvent. +func (ms EntityEvent) SetTimestamp(v pcommon.Timestamp) { + ms.state.AssertMutable() + ms.orig.TimeUnixNano = uint64(v) +} + +// EntityType returns the entitytype associated with this EntityEvent. +func (ms EntityEvent) EntityType() string { + return ms.orig.EntityType +} + +// SetEntityType replaces the entitytype associated with this EntityEvent. +func (ms EntityEvent) SetEntityType(v string) { + ms.state.AssertMutable() + ms.orig.EntityType = v +} + +// Id returns the Id associated with this EntityEvent. +func (ms EntityEvent) Id() pcommon.Map { + return pcommon.Map(internal.NewMap(&ms.orig.Id, ms.state)) +} + +// Type returns the type of the data for this EntityEvent. +// Calling this function on zero-initialized EntityEvent will cause a panic. +func (ms EntityEvent) Type() EventType { + switch ms.orig.Data.(type) { + case *otlpentities.EntityEvent_EntityState: + return EventTypeEntityState + case *otlpentities.EntityEvent_EntityDelete: + return EventTypeEntityDelete + } + return EventTypeEmpty +} + +// EntityState returns the entitystate associated with this EntityEvent. +// +// Calling this function when Type() != EventTypeEntityState returns an invalid +// zero-initialized instance of EntityState. Note that using such EntityState instance can cause panic. +// +// Calling this function on zero-initialized EntityEvent will cause a panic. +func (ms EntityEvent) EntityState() EntityState { + v, ok := ms.orig.GetData().(*otlpentities.EntityEvent_EntityState) + if !ok { + return EntityState{} + } + return newEntityState(v.EntityState, ms.state) +} + +// SetEmptyEntityState sets an empty entitystate to this EntityEvent. +// +// After this, Type() function will return EventTypeEntityState". +// +// Calling this function on zero-initialized EntityEvent will cause a panic. +func (ms EntityEvent) SetEmptyEntityState() EntityState { + ms.state.AssertMutable() + val := &otlpentities.EntityState{} + ms.orig.Data = &otlpentities.EntityEvent_EntityState{EntityState: val} + return newEntityState(val, ms.state) +} + +// EntityDelete returns the entitydelete associated with this EntityEvent. +// +// Calling this function when Type() != EventTypeEntityDelete returns an invalid +// zero-initialized instance of EntityDelete. Note that using such EntityDelete instance can cause panic. +// +// Calling this function on zero-initialized EntityEvent will cause a panic. +func (ms EntityEvent) EntityDelete() EntityDelete { + v, ok := ms.orig.GetData().(*otlpentities.EntityEvent_EntityDelete) + if !ok { + return EntityDelete{} + } + return newEntityDelete(v.EntityDelete, ms.state) +} + +// SetEmptyEntityDelete sets an empty entitydelete to this EntityEvent. +// +// After this, Type() function will return EventTypeEntityDelete". +// +// Calling this function on zero-initialized EntityEvent will cause a panic. +func (ms EntityEvent) SetEmptyEntityDelete() EntityDelete { + ms.state.AssertMutable() + val := &otlpentities.EntityDelete{} + ms.orig.Data = &otlpentities.EntityEvent_EntityDelete{EntityDelete: val} + return newEntityDelete(val, ms.state) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms EntityEvent) CopyTo(dest EntityEvent) { + dest.state.AssertMutable() + dest.SetTimestamp(ms.Timestamp()) + dest.SetEntityType(ms.EntityType()) + ms.Id().CopyTo(dest.Id()) + switch ms.Type() { + case EventTypeEntityState: + ms.EntityState().CopyTo(dest.SetEmptyEntityState()) + case EventTypeEntityDelete: + ms.EntityDelete().CopyTo(dest.SetEmptyEntityDelete()) + } + +} diff --git a/pdata/pentity/generated_entityevent_test.go b/pdata/pentity/generated_entityevent_test.go new file mode 100644 index 00000000000..8f32217d0db --- /dev/null +++ b/pdata/pentity/generated_entityevent_test.go @@ -0,0 +1,121 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" + "go.opentelemetry.io/collector/pdata/pcommon" +) + +func TestEntityEvent_MoveTo(t *testing.T) { + ms := generateTestEntityEvent() + dest := NewEntityEvent() + ms.MoveTo(dest) + assert.Equal(t, NewEntityEvent(), ms) + assert.Equal(t, generateTestEntityEvent(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newEntityEvent(&otlpentities.EntityEvent{}, &sharedState)) }) + assert.Panics(t, func() { newEntityEvent(&otlpentities.EntityEvent{}, &sharedState).MoveTo(dest) }) +} + +func TestEntityEvent_CopyTo(t *testing.T) { + ms := NewEntityEvent() + orig := NewEntityEvent() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestEntityEvent() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newEntityEvent(&otlpentities.EntityEvent{}, &sharedState)) }) +} + +func TestEntityEvent_Timestamp(t *testing.T) { + ms := NewEntityEvent() + assert.Equal(t, pcommon.Timestamp(0), ms.Timestamp()) + testValTimestamp := pcommon.Timestamp(1234567890) + ms.SetTimestamp(testValTimestamp) + assert.Equal(t, testValTimestamp, ms.Timestamp()) +} + +func TestEntityEvent_EntityType(t *testing.T) { + ms := NewEntityEvent() + assert.Equal(t, "", ms.EntityType()) + ms.SetEntityType("service") + assert.Equal(t, "service", ms.EntityType()) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { newEntityEvent(&otlpentities.EntityEvent{}, &sharedState).SetEntityType("service") }) +} + +func TestEntityEvent_Id(t *testing.T) { + ms := NewEntityEvent() + assert.Equal(t, pcommon.NewMap(), ms.Id()) + internal.FillTestMap(internal.Map(ms.Id())) + assert.Equal(t, pcommon.Map(internal.GenerateTestMap()), ms.Id()) +} + +func TestEntityEvent_Type(t *testing.T) { + tv := NewEntityEvent() + assert.Equal(t, EventTypeEmpty, tv.Type()) +} + +func TestEntityEvent_EntityState(t *testing.T) { + ms := NewEntityEvent() + fillTestEntityState(ms.SetEmptyEntityState()) + assert.Equal(t, EventTypeEntityState, ms.Type()) + assert.Equal(t, generateTestEntityState(), ms.EntityState()) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { newEntityEvent(&otlpentities.EntityEvent{}, &sharedState).SetEmptyEntityState() }) +} + +func TestEntityEvent_CopyTo_EntityState(t *testing.T) { + ms := NewEntityEvent() + fillTestEntityState(ms.SetEmptyEntityState()) + dest := NewEntityEvent() + ms.CopyTo(dest) + assert.Equal(t, ms, dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newEntityEvent(&otlpentities.EntityEvent{}, &sharedState)) }) +} + +func TestEntityEvent_EntityDelete(t *testing.T) { + ms := NewEntityEvent() + fillTestEntityDelete(ms.SetEmptyEntityDelete()) + assert.Equal(t, EventTypeEntityDelete, ms.Type()) + assert.Equal(t, generateTestEntityDelete(), ms.EntityDelete()) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { newEntityEvent(&otlpentities.EntityEvent{}, &sharedState).SetEmptyEntityDelete() }) +} + +func TestEntityEvent_CopyTo_EntityDelete(t *testing.T) { + ms := NewEntityEvent() + fillTestEntityDelete(ms.SetEmptyEntityDelete()) + dest := NewEntityEvent() + ms.CopyTo(dest) + assert.Equal(t, ms, dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newEntityEvent(&otlpentities.EntityEvent{}, &sharedState)) }) +} + +func generateTestEntityEvent() EntityEvent { + tv := NewEntityEvent() + fillTestEntityEvent(tv) + return tv +} + +func fillTestEntityEvent(tv EntityEvent) { + tv.orig.TimeUnixNano = 1234567890 + tv.orig.EntityType = "service" + internal.FillTestMap(internal.NewMap(&tv.orig.Id, tv.state)) + tv.orig.Data = &otlpentities.EntityEvent_EntityDelete{EntityDelete: &otlpentities.EntityDelete{}} + fillTestEntityDelete(newEntityDelete(tv.orig.GetEntityDelete(), tv.state)) +} diff --git a/pdata/pentity/generated_entityeventslice.go b/pdata/pentity/generated_entityeventslice.go new file mode 100644 index 00000000000..56790da2434 --- /dev/null +++ b/pdata/pentity/generated_entityeventslice.go @@ -0,0 +1,160 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "sort" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +// EntityEventSlice logically represents a slice of EntityEvent. +// +// This is a reference type. If passed by value and callee modifies it, the +// caller will see the modification. +// +// Must use NewEntityEventSlice function to create new instances. +// Important: zero-initialized instance is not valid for use. +type EntityEventSlice struct { + orig *[]*otlpentities.EntityEvent + state *internal.State +} + +func newEntityEventSlice(orig *[]*otlpentities.EntityEvent, state *internal.State) EntityEventSlice { + return EntityEventSlice{orig: orig, state: state} +} + +func (ms EntityEventSlice) getOrig() *[]*otlpentities.EntityEvent { + return ms.orig +} + +func (ms EntityEventSlice) getState() *internal.State { + return ms.state +} + +// NewEntityEventSlice creates a EntityEventSlice with 0 elements. +// Can use "EnsureCapacity" to initialize with a given capacity. +func NewEntityEventSlice() EntityEventSlice { + orig := []*otlpentities.EntityEvent(nil) + state := internal.StateMutable + return newEntityEventSlice(&orig, &state) +} + +// Len returns the number of elements in the slice. +// +// Returns "0" for a newly instance created with "NewEntityEventSlice()". +func (es EntityEventSlice) Len() int { + return len(*es.getOrig()) +} + +// At returns the element at the given index. +// +// This function is used mostly for iterating over all the values in the slice: +// +// for i := 0; i < es.Len(); i++ { +// e := es.At(i) +// ... // Do something with the element +// } +func (es EntityEventSlice) At(i int) EntityEvent { + return newEntityEvent((*es.getOrig())[i], es.getState()) +} + +// EnsureCapacity is an operation that ensures the slice has at least the specified capacity. +// 1. If the newCap <= cap then no change in capacity. +// 2. If the newCap > cap then the slice capacity will be expanded to equal newCap. +// +// Here is how a new EntityEventSlice can be initialized: +// +// es := NewEntityEventSlice() +// es.EnsureCapacity(4) +// for i := 0; i < 4; i++ { +// e := es.AppendEmpty() +// // Here should set all the values for e. +// } +func (es EntityEventSlice) EnsureCapacity(newCap int) { + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) + if newCap <= oldCap { + return + } + + newOrig := make([]*otlpentities.EntityEvent, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig +} + +// AppendEmpty will append to the end of the slice an empty EntityEvent. +// It returns the newly added EntityEvent. +func (es EntityEventSlice) AppendEmpty() EntityEvent { + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpentities.EntityEvent{}) + return es.At(es.Len() - 1) +} + +// MoveAndAppendTo moves all elements from the current slice and appends them to the dest. +// The current slice will be cleared. +func (es EntityEventSlice) MoveAndAppendTo(dest EntityEventSlice) { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { + // We can simply move the entire vector and avoid any allocations. + *dest.getOrig() = *es.getOrig() + } else { + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) + } + *es.getOrig() = nil +} + +// RemoveIf calls f sequentially for each element present in the slice. +// If f returns true, the element is removed from the slice. +func (es EntityEventSlice) RemoveIf(f func(EntityEvent) bool) { + es.getState().AssertMutable() + newLen := 0 + for i := 0; i < len(*es.getOrig()); i++ { + if f(es.At(i)) { + continue + } + if newLen == i { + // Nothing to move, element is at the right place. + newLen++ + continue + } + (*es.getOrig())[newLen] = (*es.getOrig())[i] + newLen++ + } + *es.getOrig() = (*es.getOrig())[:newLen] +} + +// CopyTo copies all elements from the current slice overriding the destination. +func (es EntityEventSlice) CopyTo(dest EntityEventSlice) { + dest.getState().AssertMutable() + srcLen := es.Len() + destCap := cap(*dest.getOrig()) + if srcLen <= destCap { + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newEntityEvent((*es.getOrig())[i], es.getState()).CopyTo(newEntityEvent((*dest.getOrig())[i], dest.getState())) + } + return + } + origs := make([]otlpentities.EntityEvent, srcLen) + wrappers := make([]*otlpentities.EntityEvent, srcLen) + for i := range *es.getOrig() { + wrappers[i] = &origs[i] + newEntityEvent((*es.getOrig())[i], es.getState()).CopyTo(newEntityEvent(wrappers[i], dest.getState())) + } + *dest.getOrig() = wrappers +} + +// Sort sorts the EntityEvent elements within EntityEventSlice given the +// provided less function so that two instances of EntityEventSlice +// can be compared. +func (es EntityEventSlice) Sort(less func(a, b EntityEvent) bool) { + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) +} diff --git a/pdata/pentity/generated_entityeventslice_test.go b/pdata/pentity/generated_entityeventslice_test.go new file mode 100644 index 00000000000..3556b73a229 --- /dev/null +++ b/pdata/pentity/generated_entityeventslice_test.go @@ -0,0 +1,154 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "testing" + "unsafe" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +func TestEntityEventSlice(t *testing.T) { + es := NewEntityEventSlice() + assert.Equal(t, 0, es.Len()) + state := internal.StateMutable + es = newEntityEventSlice(&[]*otlpentities.EntityEvent{}, &state) + assert.Equal(t, 0, es.Len()) + + emptyVal := NewEntityEvent() + testVal := generateTestEntityEvent() + for i := 0; i < 7; i++ { + el := es.AppendEmpty() + assert.Equal(t, emptyVal, es.At(i)) + fillTestEntityEvent(el) + assert.Equal(t, testVal, es.At(i)) + } + assert.Equal(t, 7, es.Len()) +} + +func TestEntityEventSliceReadOnly(t *testing.T) { + sharedState := internal.StateReadOnly + es := newEntityEventSlice(&[]*otlpentities.EntityEvent{}, &sharedState) + assert.Equal(t, 0, es.Len()) + assert.Panics(t, func() { es.AppendEmpty() }) + assert.Panics(t, func() { es.EnsureCapacity(2) }) + es2 := NewEntityEventSlice() + es.CopyTo(es2) + assert.Panics(t, func() { es2.CopyTo(es) }) + assert.Panics(t, func() { es.MoveAndAppendTo(es2) }) + assert.Panics(t, func() { es2.MoveAndAppendTo(es) }) +} + +func TestEntityEventSlice_CopyTo(t *testing.T) { + dest := NewEntityEventSlice() + // Test CopyTo to empty + NewEntityEventSlice().CopyTo(dest) + assert.Equal(t, NewEntityEventSlice(), dest) + + // Test CopyTo larger slice + generateTestEntityEventSlice().CopyTo(dest) + assert.Equal(t, generateTestEntityEventSlice(), dest) + + // Test CopyTo same size slice + generateTestEntityEventSlice().CopyTo(dest) + assert.Equal(t, generateTestEntityEventSlice(), dest) +} + +func TestEntityEventSlice_EnsureCapacity(t *testing.T) { + es := generateTestEntityEventSlice() + + // Test ensure smaller capacity. + const ensureSmallLen = 4 + es.EnsureCapacity(ensureSmallLen) + assert.Less(t, ensureSmallLen, es.Len()) + assert.Equal(t, es.Len(), cap(*es.getOrig())) + assert.Equal(t, generateTestEntityEventSlice(), es) + + // Test ensure larger capacity + const ensureLargeLen = 9 + es.EnsureCapacity(ensureLargeLen) + assert.Less(t, generateTestEntityEventSlice().Len(), ensureLargeLen) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) + assert.Equal(t, generateTestEntityEventSlice(), es) +} + +func TestEntityEventSlice_MoveAndAppendTo(t *testing.T) { + // Test MoveAndAppendTo to empty + expectedSlice := generateTestEntityEventSlice() + dest := NewEntityEventSlice() + src := generateTestEntityEventSlice() + src.MoveAndAppendTo(dest) + assert.Equal(t, generateTestEntityEventSlice(), dest) + assert.Equal(t, 0, src.Len()) + assert.Equal(t, expectedSlice.Len(), dest.Len()) + + // Test MoveAndAppendTo empty slice + src.MoveAndAppendTo(dest) + assert.Equal(t, generateTestEntityEventSlice(), dest) + assert.Equal(t, 0, src.Len()) + assert.Equal(t, expectedSlice.Len(), dest.Len()) + + // Test MoveAndAppendTo not empty slice + generateTestEntityEventSlice().MoveAndAppendTo(dest) + assert.Equal(t, 2*expectedSlice.Len(), dest.Len()) + for i := 0; i < expectedSlice.Len(); i++ { + assert.Equal(t, expectedSlice.At(i), dest.At(i)) + assert.Equal(t, expectedSlice.At(i), dest.At(i+expectedSlice.Len())) + } +} + +func TestEntityEventSlice_RemoveIf(t *testing.T) { + // Test RemoveIf on empty slice + emptySlice := NewEntityEventSlice() + emptySlice.RemoveIf(func(el EntityEvent) bool { + t.Fail() + return false + }) + + // Test RemoveIf + filtered := generateTestEntityEventSlice() + pos := 0 + filtered.RemoveIf(func(el EntityEvent) bool { + pos++ + return pos%3 == 0 + }) + assert.Equal(t, 5, filtered.Len()) +} + +func TestEntityEventSlice_Sort(t *testing.T) { + es := generateTestEntityEventSlice() + es.Sort(func(a, b EntityEvent) bool { + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) + }) + for i := 1; i < es.Len(); i++ { + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) + } + es.Sort(func(a, b EntityEvent) bool { + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) + }) + for i := 1; i < es.Len(); i++ { + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) + } +} + +func generateTestEntityEventSlice() EntityEventSlice { + es := NewEntityEventSlice() + fillTestEntityEventSlice(es) + return es +} + +func fillTestEntityEventSlice(es EntityEventSlice) { + *es.orig = make([]*otlpentities.EntityEvent, 7) + for i := 0; i < 7; i++ { + (*es.orig)[i] = &otlpentities.EntityEvent{} + fillTestEntityEvent(newEntityEvent((*es.orig)[i], es.state)) + } +} diff --git a/pdata/pentity/generated_entitystate.go b/pdata/pentity/generated_entitystate.go new file mode 100644 index 00000000000..7c331d1a362 --- /dev/null +++ b/pdata/pentity/generated_entitystate.go @@ -0,0 +1,78 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" + "go.opentelemetry.io/collector/pdata/pcommon" +) + +// EntityState are experimental implementation of OpenTelemetry Entity Data Model. + +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewEntityState function to create new instances. +// Important: zero-initialized instance is not valid for use. +type EntityState struct { + orig *otlpentities.EntityState + state *internal.State +} + +func newEntityState(orig *otlpentities.EntityState, state *internal.State) EntityState { + return EntityState{orig: orig, state: state} +} + +// NewEntityState creates a new empty EntityState. +// +// 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 NewEntityState() EntityState { + state := internal.StateMutable + return newEntityState(&otlpentities.EntityState{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms EntityState) MoveTo(dest EntityState) { + ms.state.AssertMutable() + dest.state.AssertMutable() + *dest.orig = *ms.orig + *ms.orig = otlpentities.EntityState{} +} + +func (ms EntityState) getOrig() *otlpentities.EntityState { + return ms.orig +} + +func (ms EntityState) getState() *internal.State { + return ms.state +} + +// Attributes returns the Attributes associated with this EntityState. +func (ms EntityState) Attributes() pcommon.Map { + return pcommon.Map(internal.NewMap(&ms.orig.Attributes, ms.state)) +} + +// DroppedAttributesCount returns the droppedattributescount associated with this EntityState. +func (ms EntityState) DroppedAttributesCount() uint32 { + return ms.orig.DroppedAttributesCount +} + +// SetDroppedAttributesCount replaces the droppedattributescount associated with this EntityState. +func (ms EntityState) SetDroppedAttributesCount(v uint32) { + ms.state.AssertMutable() + ms.orig.DroppedAttributesCount = v +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms EntityState) CopyTo(dest EntityState) { + dest.state.AssertMutable() + ms.Attributes().CopyTo(dest.Attributes()) + dest.SetDroppedAttributesCount(ms.DroppedAttributesCount()) +} diff --git a/pdata/pentity/generated_entitystate_test.go b/pdata/pentity/generated_entitystate_test.go new file mode 100644 index 00000000000..6f455dd8adb --- /dev/null +++ b/pdata/pentity/generated_entitystate_test.go @@ -0,0 +1,69 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" + "go.opentelemetry.io/collector/pdata/pcommon" +) + +func TestEntityState_MoveTo(t *testing.T) { + ms := generateTestEntityState() + dest := NewEntityState() + ms.MoveTo(dest) + assert.Equal(t, NewEntityState(), ms) + assert.Equal(t, generateTestEntityState(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newEntityState(&otlpentities.EntityState{}, &sharedState)) }) + assert.Panics(t, func() { newEntityState(&otlpentities.EntityState{}, &sharedState).MoveTo(dest) }) +} + +func TestEntityState_CopyTo(t *testing.T) { + ms := NewEntityState() + orig := NewEntityState() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestEntityState() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newEntityState(&otlpentities.EntityState{}, &sharedState)) }) +} + +func TestEntityState_Attributes(t *testing.T) { + ms := NewEntityState() + assert.Equal(t, pcommon.NewMap(), ms.Attributes()) + internal.FillTestMap(internal.Map(ms.Attributes())) + assert.Equal(t, pcommon.Map(internal.GenerateTestMap()), ms.Attributes()) +} + +func TestEntityState_DroppedAttributesCount(t *testing.T) { + ms := NewEntityState() + assert.Equal(t, uint32(0), ms.DroppedAttributesCount()) + ms.SetDroppedAttributesCount(uint32(17)) + assert.Equal(t, uint32(17), ms.DroppedAttributesCount()) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + newEntityState(&otlpentities.EntityState{}, &sharedState).SetDroppedAttributesCount(uint32(17)) + }) +} + +func generateTestEntityState() EntityState { + tv := NewEntityState() + fillTestEntityState(tv) + return tv +} + +func fillTestEntityState(tv EntityState) { + internal.FillTestMap(internal.NewMap(&tv.orig.Attributes, tv.state)) + tv.orig.DroppedAttributesCount = uint32(17) +} diff --git a/pdata/pentity/generated_entitystateslice.go b/pdata/pentity/generated_entitystateslice.go new file mode 100644 index 00000000000..a4df068ae84 --- /dev/null +++ b/pdata/pentity/generated_entitystateslice.go @@ -0,0 +1,152 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "sort" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +// EntityStateSlice logically represents a slice of EntityState. +// +// This is a reference type. If passed by value and callee modifies it, the +// caller will see the modification. +// +// Must use NewEntityStateSlice function to create new instances. +// Important: zero-initialized instance is not valid for use. +type EntityStateSlice struct { + orig *[]*otlpentities.EntityState + state *internal.State +} + +func newEntityStateSlice(orig *[]*otlpentities.EntityState, state *internal.State) EntityStateSlice { + return EntityStateSlice{orig: orig, state: state} +} + +// NewEntityStateSlice creates a EntityStateSlice with 0 elements. +// Can use "EnsureCapacity" to initialize with a given capacity. +func NewEntityStateSlice() EntityStateSlice { + orig := []*otlpentities.EntityState(nil) + state := internal.StateMutable + return newEntityStateSlice(&orig, &state) +} + +// Len returns the number of elements in the slice. +// +// Returns "0" for a newly instance created with "NewEntityStateSlice()". +func (es EntityStateSlice) Len() int { + return len(*es.orig) +} + +// At returns the element at the given index. +// +// This function is used mostly for iterating over all the values in the slice: +// +// for i := 0; i < es.Len(); i++ { +// e := es.At(i) +// ... // Do something with the element +// } +func (es EntityStateSlice) At(i int) EntityState { + return newEntityState((*es.orig)[i], es.state) +} + +// EnsureCapacity is an operation that ensures the slice has at least the specified capacity. +// 1. If the newCap <= cap then no change in capacity. +// 2. If the newCap > cap then the slice capacity will be expanded to equal newCap. +// +// Here is how a new EntityStateSlice can be initialized: +// +// es := NewEntityStateSlice() +// es.EnsureCapacity(4) +// for i := 0; i < 4; i++ { +// e := es.AppendEmpty() +// // Here should set all the values for e. +// } +func (es EntityStateSlice) EnsureCapacity(newCap int) { + es.state.AssertMutable() + oldCap := cap(*es.orig) + if newCap <= oldCap { + return + } + + newOrig := make([]*otlpentities.EntityState, len(*es.orig), newCap) + copy(newOrig, *es.orig) + *es.orig = newOrig +} + +// AppendEmpty will append to the end of the slice an empty EntityState. +// It returns the newly added EntityState. +func (es EntityStateSlice) AppendEmpty() EntityState { + es.state.AssertMutable() + *es.orig = append(*es.orig, &otlpentities.EntityState{}) + return es.At(es.Len() - 1) +} + +// MoveAndAppendTo moves all elements from the current slice and appends them to the dest. +// The current slice will be cleared. +func (es EntityStateSlice) MoveAndAppendTo(dest EntityStateSlice) { + es.state.AssertMutable() + dest.state.AssertMutable() + if *dest.orig == nil { + // We can simply move the entire vector and avoid any allocations. + *dest.orig = *es.orig + } else { + *dest.orig = append(*dest.orig, *es.orig...) + } + *es.orig = nil +} + +// RemoveIf calls f sequentially for each element present in the slice. +// If f returns true, the element is removed from the slice. +func (es EntityStateSlice) RemoveIf(f func(EntityState) bool) { + es.state.AssertMutable() + newLen := 0 + for i := 0; i < len(*es.orig); i++ { + if f(es.At(i)) { + continue + } + if newLen == i { + // Nothing to move, element is at the right place. + newLen++ + continue + } + (*es.orig)[newLen] = (*es.orig)[i] + newLen++ + } + *es.orig = (*es.orig)[:newLen] +} + +// CopyTo copies all elements from the current slice overriding the destination. +func (es EntityStateSlice) CopyTo(dest EntityStateSlice) { + dest.state.AssertMutable() + srcLen := es.Len() + destCap := cap(*dest.orig) + if srcLen <= destCap { + (*dest.orig) = (*dest.orig)[:srcLen:destCap] + for i := range *es.orig { + newEntityState((*es.orig)[i], es.state).CopyTo(newEntityState((*dest.orig)[i], dest.state)) + } + return + } + origs := make([]otlpentities.EntityState, srcLen) + wrappers := make([]*otlpentities.EntityState, srcLen) + for i := range *es.orig { + wrappers[i] = &origs[i] + newEntityState((*es.orig)[i], es.state).CopyTo(newEntityState(wrappers[i], dest.state)) + } + *dest.orig = wrappers +} + +// Sort sorts the EntityState elements within EntityStateSlice given the +// provided less function so that two instances of EntityStateSlice +// can be compared. +func (es EntityStateSlice) Sort(less func(a, b EntityState) bool) { + es.state.AssertMutable() + sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) +} diff --git a/pdata/pentity/generated_entitystateslice_test.go b/pdata/pentity/generated_entitystateslice_test.go new file mode 100644 index 00000000000..cfa145b5b98 --- /dev/null +++ b/pdata/pentity/generated_entitystateslice_test.go @@ -0,0 +1,154 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "testing" + "unsafe" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +func TestEntityStateSlice(t *testing.T) { + es := NewEntityStateSlice() + assert.Equal(t, 0, es.Len()) + state := internal.StateMutable + es = newEntityStateSlice(&[]*otlpentities.EntityState{}, &state) + assert.Equal(t, 0, es.Len()) + + emptyVal := NewEntityState() + testVal := generateTestEntityState() + for i := 0; i < 7; i++ { + el := es.AppendEmpty() + assert.Equal(t, emptyVal, es.At(i)) + fillTestEntityState(el) + assert.Equal(t, testVal, es.At(i)) + } + assert.Equal(t, 7, es.Len()) +} + +func TestEntityStateSliceReadOnly(t *testing.T) { + sharedState := internal.StateReadOnly + es := newEntityStateSlice(&[]*otlpentities.EntityState{}, &sharedState) + assert.Equal(t, 0, es.Len()) + assert.Panics(t, func() { es.AppendEmpty() }) + assert.Panics(t, func() { es.EnsureCapacity(2) }) + es2 := NewEntityStateSlice() + es.CopyTo(es2) + assert.Panics(t, func() { es2.CopyTo(es) }) + assert.Panics(t, func() { es.MoveAndAppendTo(es2) }) + assert.Panics(t, func() { es2.MoveAndAppendTo(es) }) +} + +func TestEntityStateSlice_CopyTo(t *testing.T) { + dest := NewEntityStateSlice() + // Test CopyTo to empty + NewEntityStateSlice().CopyTo(dest) + assert.Equal(t, NewEntityStateSlice(), dest) + + // Test CopyTo larger slice + generateTestEntityStateSlice().CopyTo(dest) + assert.Equal(t, generateTestEntityStateSlice(), dest) + + // Test CopyTo same size slice + generateTestEntityStateSlice().CopyTo(dest) + assert.Equal(t, generateTestEntityStateSlice(), dest) +} + +func TestEntityStateSlice_EnsureCapacity(t *testing.T) { + es := generateTestEntityStateSlice() + + // Test ensure smaller capacity. + const ensureSmallLen = 4 + es.EnsureCapacity(ensureSmallLen) + assert.Less(t, ensureSmallLen, es.Len()) + assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, generateTestEntityStateSlice(), es) + + // Test ensure larger capacity + const ensureLargeLen = 9 + es.EnsureCapacity(ensureLargeLen) + assert.Less(t, generateTestEntityStateSlice().Len(), ensureLargeLen) + assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, generateTestEntityStateSlice(), es) +} + +func TestEntityStateSlice_MoveAndAppendTo(t *testing.T) { + // Test MoveAndAppendTo to empty + expectedSlice := generateTestEntityStateSlice() + dest := NewEntityStateSlice() + src := generateTestEntityStateSlice() + src.MoveAndAppendTo(dest) + assert.Equal(t, generateTestEntityStateSlice(), dest) + assert.Equal(t, 0, src.Len()) + assert.Equal(t, expectedSlice.Len(), dest.Len()) + + // Test MoveAndAppendTo empty slice + src.MoveAndAppendTo(dest) + assert.Equal(t, generateTestEntityStateSlice(), dest) + assert.Equal(t, 0, src.Len()) + assert.Equal(t, expectedSlice.Len(), dest.Len()) + + // Test MoveAndAppendTo not empty slice + generateTestEntityStateSlice().MoveAndAppendTo(dest) + assert.Equal(t, 2*expectedSlice.Len(), dest.Len()) + for i := 0; i < expectedSlice.Len(); i++ { + assert.Equal(t, expectedSlice.At(i), dest.At(i)) + assert.Equal(t, expectedSlice.At(i), dest.At(i+expectedSlice.Len())) + } +} + +func TestEntityStateSlice_RemoveIf(t *testing.T) { + // Test RemoveIf on empty slice + emptySlice := NewEntityStateSlice() + emptySlice.RemoveIf(func(el EntityState) bool { + t.Fail() + return false + }) + + // Test RemoveIf + filtered := generateTestEntityStateSlice() + pos := 0 + filtered.RemoveIf(func(el EntityState) bool { + pos++ + return pos%3 == 0 + }) + assert.Equal(t, 5, filtered.Len()) +} + +func TestEntityStateSlice_Sort(t *testing.T) { + es := generateTestEntityStateSlice() + es.Sort(func(a, b EntityState) bool { + return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + }) + for i := 1; i < es.Len(); i++ { + assert.True(t, uintptr(unsafe.Pointer(es.At(i-1).orig)) < uintptr(unsafe.Pointer(es.At(i).orig))) + } + es.Sort(func(a, b EntityState) bool { + return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + }) + for i := 1; i < es.Len(); i++ { + assert.True(t, uintptr(unsafe.Pointer(es.At(i-1).orig)) > uintptr(unsafe.Pointer(es.At(i).orig))) + } +} + +func generateTestEntityStateSlice() EntityStateSlice { + es := NewEntityStateSlice() + fillTestEntityStateSlice(es) + return es +} + +func fillTestEntityStateSlice(es EntityStateSlice) { + *es.orig = make([]*otlpentities.EntityState, 7) + for i := 0; i < 7; i++ { + (*es.orig)[i] = &otlpentities.EntityState{} + fillTestEntityState(newEntityState((*es.orig)[i], es.state)) + } +} diff --git a/pdata/pentity/generated_scopeentities.go b/pdata/pentity/generated_scopeentities.go new file mode 100644 index 00000000000..0f62e94a792 --- /dev/null +++ b/pdata/pentity/generated_scopeentities.go @@ -0,0 +1,84 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" + "go.opentelemetry.io/collector/pdata/pcommon" +) + +// ScopeEntities is a collection of entities from a LibraryInstrumentation. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewScopeEntities function to create new instances. +// Important: zero-initialized instance is not valid for use. +type ScopeEntities struct { + orig *otlpentities.ScopeEntities + state *internal.State +} + +func newScopeEntities(orig *otlpentities.ScopeEntities, state *internal.State) ScopeEntities { + return ScopeEntities{orig: orig, state: state} +} + +// NewScopeEntities creates a new empty ScopeEntities. +// +// 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 NewScopeEntities() ScopeEntities { + state := internal.StateMutable + return newScopeEntities(&otlpentities.ScopeEntities{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms ScopeEntities) MoveTo(dest ScopeEntities) { + ms.state.AssertMutable() + dest.state.AssertMutable() + *dest.orig = *ms.orig + *ms.orig = otlpentities.ScopeEntities{} +} + +func (ms ScopeEntities) getOrig() *otlpentities.ScopeEntities { + return ms.orig +} + +func (ms ScopeEntities) getState() *internal.State { + return ms.state +} + +// Scope returns the scope associated with this ScopeEntities. +func (ms ScopeEntities) Scope() pcommon.InstrumentationScope { + return pcommon.InstrumentationScope(internal.NewInstrumentationScope(&ms.orig.Scope, ms.state)) +} + +// SchemaUrl returns the schemaurl associated with this ScopeEntities. +func (ms ScopeEntities) SchemaUrl() string { + return ms.orig.SchemaUrl +} + +// SetSchemaUrl replaces the schemaurl associated with this ScopeEntities. +func (ms ScopeEntities) SetSchemaUrl(v string) { + ms.state.AssertMutable() + ms.orig.SchemaUrl = v +} + +// EntityEvents returns the EntityEvents associated with this ScopeEntities. +func (ms ScopeEntities) EntityEvents() EntityEventSlice { + return newEntityEventSlice(&ms.orig.EntityEvents, ms.state) +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms ScopeEntities) CopyTo(dest ScopeEntities) { + dest.state.AssertMutable() + ms.Scope().CopyTo(dest.Scope()) + dest.SetSchemaUrl(ms.SchemaUrl()) + ms.EntityEvents().CopyTo(dest.EntityEvents()) +} diff --git a/pdata/pentity/generated_scopeentities_test.go b/pdata/pentity/generated_scopeentities_test.go new file mode 100644 index 00000000000..2e03b67f8a4 --- /dev/null +++ b/pdata/pentity/generated_scopeentities_test.go @@ -0,0 +1,76 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" + "go.opentelemetry.io/collector/pdata/pcommon" +) + +func TestScopeEntities_MoveTo(t *testing.T) { + ms := generateTestScopeEntities() + dest := NewScopeEntities() + ms.MoveTo(dest) + assert.Equal(t, NewScopeEntities(), ms) + assert.Equal(t, generateTestScopeEntities(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.MoveTo(newScopeEntities(&otlpentities.ScopeEntities{}, &sharedState)) }) + assert.Panics(t, func() { newScopeEntities(&otlpentities.ScopeEntities{}, &sharedState).MoveTo(dest) }) +} + +func TestScopeEntities_CopyTo(t *testing.T) { + ms := NewScopeEntities() + orig := NewScopeEntities() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestScopeEntities() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { ms.CopyTo(newScopeEntities(&otlpentities.ScopeEntities{}, &sharedState)) }) +} + +func TestScopeEntities_Scope(t *testing.T) { + ms := NewScopeEntities() + internal.FillTestInstrumentationScope(internal.InstrumentationScope(ms.Scope())) + assert.Equal(t, pcommon.InstrumentationScope(internal.GenerateTestInstrumentationScope()), ms.Scope()) +} + +func TestScopeEntities_SchemaUrl(t *testing.T) { + ms := NewScopeEntities() + assert.Equal(t, "", ms.SchemaUrl()) + ms.SetSchemaUrl("https://opentelemetry.io/schemas/1.5.0") + assert.Equal(t, "https://opentelemetry.io/schemas/1.5.0", ms.SchemaUrl()) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + newScopeEntities(&otlpentities.ScopeEntities{}, &sharedState).SetSchemaUrl("https://opentelemetry.io/schemas/1.5.0") + }) +} + +func TestScopeEntities_EntityEvents(t *testing.T) { + ms := NewScopeEntities() + assert.Equal(t, NewEntityEventSlice(), ms.EntityEvents()) + fillTestEntityEventSlice(ms.EntityEvents()) + assert.Equal(t, generateTestEntityEventSlice(), ms.EntityEvents()) +} + +func generateTestScopeEntities() ScopeEntities { + tv := NewScopeEntities() + fillTestScopeEntities(tv) + return tv +} + +func fillTestScopeEntities(tv ScopeEntities) { + internal.FillTestInstrumentationScope(internal.NewInstrumentationScope(&tv.orig.Scope, tv.state)) + tv.orig.SchemaUrl = "https://opentelemetry.io/schemas/1.5.0" + fillTestEntityEventSlice(newEntityEventSlice(&tv.orig.EntityEvents, tv.state)) +} diff --git a/pdata/pentity/generated_scopeentitiesslice.go b/pdata/pentity/generated_scopeentitiesslice.go new file mode 100644 index 00000000000..a9590cea6a1 --- /dev/null +++ b/pdata/pentity/generated_scopeentitiesslice.go @@ -0,0 +1,160 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "sort" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +// ScopeEntitiesSlice logically represents a slice of ScopeEntities. +// +// This is a reference type. If passed by value and callee modifies it, the +// caller will see the modification. +// +// Must use NewScopeEntitiesSlice function to create new instances. +// Important: zero-initialized instance is not valid for use. +type ScopeEntitiesSlice struct { + orig *[]*otlpentities.ScopeEntities + state *internal.State +} + +func newScopeEntitiesSlice(orig *[]*otlpentities.ScopeEntities, state *internal.State) ScopeEntitiesSlice { + return ScopeEntitiesSlice{orig: orig, state: state} +} + +func (ms ScopeEntitiesSlice) getOrig() *[]*otlpentities.ScopeEntities { + return ms.orig +} + +func (ms ScopeEntitiesSlice) getState() *internal.State { + return ms.state +} + +// NewScopeEntitiesSlice creates a ScopeEntitiesSlice with 0 elements. +// Can use "EnsureCapacity" to initialize with a given capacity. +func NewScopeEntitiesSlice() ScopeEntitiesSlice { + orig := []*otlpentities.ScopeEntities(nil) + state := internal.StateMutable + return newScopeEntitiesSlice(&orig, &state) +} + +// Len returns the number of elements in the slice. +// +// Returns "0" for a newly instance created with "NewScopeEntitiesSlice()". +func (es ScopeEntitiesSlice) Len() int { + return len(*es.getOrig()) +} + +// At returns the element at the given index. +// +// This function is used mostly for iterating over all the values in the slice: +// +// for i := 0; i < es.Len(); i++ { +// e := es.At(i) +// ... // Do something with the element +// } +func (es ScopeEntitiesSlice) At(i int) ScopeEntities { + return newScopeEntities((*es.getOrig())[i], es.getState()) +} + +// EnsureCapacity is an operation that ensures the slice has at least the specified capacity. +// 1. If the newCap <= cap then no change in capacity. +// 2. If the newCap > cap then the slice capacity will be expanded to equal newCap. +// +// Here is how a new ScopeEntitiesSlice can be initialized: +// +// es := NewScopeEntitiesSlice() +// es.EnsureCapacity(4) +// for i := 0; i < 4; i++ { +// e := es.AppendEmpty() +// // Here should set all the values for e. +// } +func (es ScopeEntitiesSlice) EnsureCapacity(newCap int) { + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) + if newCap <= oldCap { + return + } + + newOrig := make([]*otlpentities.ScopeEntities, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig +} + +// AppendEmpty will append to the end of the slice an empty ScopeEntities. +// It returns the newly added ScopeEntities. +func (es ScopeEntitiesSlice) AppendEmpty() ScopeEntities { + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpentities.ScopeEntities{}) + return es.At(es.Len() - 1) +} + +// MoveAndAppendTo moves all elements from the current slice and appends them to the dest. +// The current slice will be cleared. +func (es ScopeEntitiesSlice) MoveAndAppendTo(dest ScopeEntitiesSlice) { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { + // We can simply move the entire vector and avoid any allocations. + *dest.getOrig() = *es.getOrig() + } else { + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) + } + *es.getOrig() = nil +} + +// RemoveIf calls f sequentially for each element present in the slice. +// If f returns true, the element is removed from the slice. +func (es ScopeEntitiesSlice) RemoveIf(f func(ScopeEntities) bool) { + es.getState().AssertMutable() + newLen := 0 + for i := 0; i < len(*es.getOrig()); i++ { + if f(es.At(i)) { + continue + } + if newLen == i { + // Nothing to move, element is at the right place. + newLen++ + continue + } + (*es.getOrig())[newLen] = (*es.getOrig())[i] + newLen++ + } + *es.getOrig() = (*es.getOrig())[:newLen] +} + +// CopyTo copies all elements from the current slice overriding the destination. +func (es ScopeEntitiesSlice) CopyTo(dest ScopeEntitiesSlice) { + dest.getState().AssertMutable() + srcLen := es.Len() + destCap := cap(*dest.getOrig()) + if srcLen <= destCap { + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newScopeEntities((*es.getOrig())[i], es.getState()).CopyTo(newScopeEntities((*dest.getOrig())[i], dest.getState())) + } + return + } + origs := make([]otlpentities.ScopeEntities, srcLen) + wrappers := make([]*otlpentities.ScopeEntities, srcLen) + for i := range *es.getOrig() { + wrappers[i] = &origs[i] + newScopeEntities((*es.getOrig())[i], es.getState()).CopyTo(newScopeEntities(wrappers[i], dest.getState())) + } + *dest.getOrig() = wrappers +} + +// Sort sorts the ScopeEntities elements within ScopeEntitiesSlice given the +// provided less function so that two instances of ScopeEntitiesSlice +// can be compared. +func (es ScopeEntitiesSlice) Sort(less func(a, b ScopeEntities) bool) { + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) +} diff --git a/pdata/pentity/generated_scopeentitiesslice_test.go b/pdata/pentity/generated_scopeentitiesslice_test.go new file mode 100644 index 00000000000..0f0a61952fe --- /dev/null +++ b/pdata/pentity/generated_scopeentitiesslice_test.go @@ -0,0 +1,154 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentity + +import ( + "testing" + "unsafe" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpentities "go.opentelemetry.io/collector/pdata/internal/data/protogen/entities/v1" +) + +func TestScopeEntitiesSlice(t *testing.T) { + es := NewScopeEntitiesSlice() + assert.Equal(t, 0, es.Len()) + state := internal.StateMutable + es = newScopeEntitiesSlice(&[]*otlpentities.ScopeEntities{}, &state) + assert.Equal(t, 0, es.Len()) + + emptyVal := NewScopeEntities() + testVal := generateTestScopeEntities() + for i := 0; i < 7; i++ { + el := es.AppendEmpty() + assert.Equal(t, emptyVal, es.At(i)) + fillTestScopeEntities(el) + assert.Equal(t, testVal, es.At(i)) + } + assert.Equal(t, 7, es.Len()) +} + +func TestScopeEntitiesSliceReadOnly(t *testing.T) { + sharedState := internal.StateReadOnly + es := newScopeEntitiesSlice(&[]*otlpentities.ScopeEntities{}, &sharedState) + assert.Equal(t, 0, es.Len()) + assert.Panics(t, func() { es.AppendEmpty() }) + assert.Panics(t, func() { es.EnsureCapacity(2) }) + es2 := NewScopeEntitiesSlice() + es.CopyTo(es2) + assert.Panics(t, func() { es2.CopyTo(es) }) + assert.Panics(t, func() { es.MoveAndAppendTo(es2) }) + assert.Panics(t, func() { es2.MoveAndAppendTo(es) }) +} + +func TestScopeEntitiesSlice_CopyTo(t *testing.T) { + dest := NewScopeEntitiesSlice() + // Test CopyTo to empty + NewScopeEntitiesSlice().CopyTo(dest) + assert.Equal(t, NewScopeEntitiesSlice(), dest) + + // Test CopyTo larger slice + generateTestScopeEntitiesSlice().CopyTo(dest) + assert.Equal(t, generateTestScopeEntitiesSlice(), dest) + + // Test CopyTo same size slice + generateTestScopeEntitiesSlice().CopyTo(dest) + assert.Equal(t, generateTestScopeEntitiesSlice(), dest) +} + +func TestScopeEntitiesSlice_EnsureCapacity(t *testing.T) { + es := generateTestScopeEntitiesSlice() + + // Test ensure smaller capacity. + const ensureSmallLen = 4 + es.EnsureCapacity(ensureSmallLen) + assert.Less(t, ensureSmallLen, es.Len()) + assert.Equal(t, es.Len(), cap(*es.getOrig())) + assert.Equal(t, generateTestScopeEntitiesSlice(), es) + + // Test ensure larger capacity + const ensureLargeLen = 9 + es.EnsureCapacity(ensureLargeLen) + assert.Less(t, generateTestScopeEntitiesSlice().Len(), ensureLargeLen) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) + assert.Equal(t, generateTestScopeEntitiesSlice(), es) +} + +func TestScopeEntitiesSlice_MoveAndAppendTo(t *testing.T) { + // Test MoveAndAppendTo to empty + expectedSlice := generateTestScopeEntitiesSlice() + dest := NewScopeEntitiesSlice() + src := generateTestScopeEntitiesSlice() + src.MoveAndAppendTo(dest) + assert.Equal(t, generateTestScopeEntitiesSlice(), dest) + assert.Equal(t, 0, src.Len()) + assert.Equal(t, expectedSlice.Len(), dest.Len()) + + // Test MoveAndAppendTo empty slice + src.MoveAndAppendTo(dest) + assert.Equal(t, generateTestScopeEntitiesSlice(), dest) + assert.Equal(t, 0, src.Len()) + assert.Equal(t, expectedSlice.Len(), dest.Len()) + + // Test MoveAndAppendTo not empty slice + generateTestScopeEntitiesSlice().MoveAndAppendTo(dest) + assert.Equal(t, 2*expectedSlice.Len(), dest.Len()) + for i := 0; i < expectedSlice.Len(); i++ { + assert.Equal(t, expectedSlice.At(i), dest.At(i)) + assert.Equal(t, expectedSlice.At(i), dest.At(i+expectedSlice.Len())) + } +} + +func TestScopeEntitiesSlice_RemoveIf(t *testing.T) { + // Test RemoveIf on empty slice + emptySlice := NewScopeEntitiesSlice() + emptySlice.RemoveIf(func(el ScopeEntities) bool { + t.Fail() + return false + }) + + // Test RemoveIf + filtered := generateTestScopeEntitiesSlice() + pos := 0 + filtered.RemoveIf(func(el ScopeEntities) bool { + pos++ + return pos%3 == 0 + }) + assert.Equal(t, 5, filtered.Len()) +} + +func TestScopeEntitiesSlice_Sort(t *testing.T) { + es := generateTestScopeEntitiesSlice() + es.Sort(func(a, b ScopeEntities) bool { + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) + }) + for i := 1; i < es.Len(); i++ { + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) + } + es.Sort(func(a, b ScopeEntities) bool { + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) + }) + for i := 1; i < es.Len(); i++ { + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) + } +} + +func generateTestScopeEntitiesSlice() ScopeEntitiesSlice { + es := NewScopeEntitiesSlice() + fillTestScopeEntitiesSlice(es) + return es +} + +func fillTestScopeEntitiesSlice(es ScopeEntitiesSlice) { + *es.orig = make([]*otlpentities.ScopeEntities, 7) + for i := 0; i < 7; i++ { + (*es.orig)[i] = &otlpentities.ScopeEntities{} + fillTestScopeEntities(newScopeEntities((*es.orig)[i], es.state)) + } +} diff --git a/pdata/pentity/pentityotlp/generated_exportpartialsuccess.go b/pdata/pentity/pentityotlp/generated_exportpartialsuccess.go new file mode 100644 index 00000000000..0f832e724c0 --- /dev/null +++ b/pdata/pentity/pentityotlp/generated_exportpartialsuccess.go @@ -0,0 +1,83 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentityotlp + +import ( + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorentity "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/entities/v1" +) + +// ExportPartialSuccess represents the details of a partially successful export request. +// +// This is a reference type, if passed by value and callee modifies it the +// caller will see the modification. +// +// Must use NewExportPartialSuccess function to create new instances. +// Important: zero-initialized instance is not valid for use. +type ExportPartialSuccess struct { + orig *otlpcollectorentity.ExportEntitiesPartialSuccess + state *internal.State +} + +func newExportPartialSuccess(orig *otlpcollectorentity.ExportEntitiesPartialSuccess, state *internal.State) ExportPartialSuccess { + return ExportPartialSuccess{orig: orig, state: state} +} + +// NewExportPartialSuccess creates a new empty ExportPartialSuccess. +// +// 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 NewExportPartialSuccess() ExportPartialSuccess { + state := internal.StateMutable + return newExportPartialSuccess(&otlpcollectorentity.ExportEntitiesPartialSuccess{}, &state) +} + +// MoveTo moves all properties from the current struct overriding the destination and +// resetting the current instance to its zero value +func (ms ExportPartialSuccess) MoveTo(dest ExportPartialSuccess) { + ms.state.AssertMutable() + dest.state.AssertMutable() + *dest.orig = *ms.orig + *ms.orig = otlpcollectorentity.ExportEntitiesPartialSuccess{} +} + +func (ms ExportPartialSuccess) getOrig() *otlpcollectorentity.ExportEntitiesPartialSuccess { + return ms.orig +} + +func (ms ExportPartialSuccess) getState() *internal.State { + return ms.state +} + +// RejectedEntities returns the rejectedentities associated with this ExportPartialSuccess. +func (ms ExportPartialSuccess) RejectedEntities() int64 { + return ms.orig.RejectedEntities +} + +// SetRejectedEntities replaces the rejectedentities associated with this ExportPartialSuccess. +func (ms ExportPartialSuccess) SetRejectedEntities(v int64) { + ms.state.AssertMutable() + ms.orig.RejectedEntities = v +} + +// ErrorMessage returns the errormessage associated with this ExportPartialSuccess. +func (ms ExportPartialSuccess) ErrorMessage() string { + return ms.orig.ErrorMessage +} + +// SetErrorMessage replaces the errormessage associated with this ExportPartialSuccess. +func (ms ExportPartialSuccess) SetErrorMessage(v string) { + ms.state.AssertMutable() + ms.orig.ErrorMessage = v +} + +// CopyTo copies all properties from the current struct overriding the destination. +func (ms ExportPartialSuccess) CopyTo(dest ExportPartialSuccess) { + dest.state.AssertMutable() + dest.SetRejectedEntities(ms.RejectedEntities()) + dest.SetErrorMessage(ms.ErrorMessage()) +} diff --git a/pdata/pentity/pentityotlp/generated_exportpartialsuccess_test.go b/pdata/pentity/pentityotlp/generated_exportpartialsuccess_test.go new file mode 100644 index 00000000000..cbd0d5df52b --- /dev/null +++ b/pdata/pentity/pentityotlp/generated_exportpartialsuccess_test.go @@ -0,0 +1,78 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package pentityotlp + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/collector/pdata/internal" + otlpcollectorentity "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/entities/v1" +) + +func TestExportPartialSuccess_MoveTo(t *testing.T) { + ms := generateTestExportPartialSuccess() + dest := NewExportPartialSuccess() + ms.MoveTo(dest) + assert.Equal(t, NewExportPartialSuccess(), ms) + assert.Equal(t, generateTestExportPartialSuccess(), dest) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + ms.MoveTo(newExportPartialSuccess(&otlpcollectorentity.ExportEntitiesPartialSuccess{}, &sharedState)) + }) + assert.Panics(t, func() { + newExportPartialSuccess(&otlpcollectorentity.ExportEntitiesPartialSuccess{}, &sharedState).MoveTo(dest) + }) +} + +func TestExportPartialSuccess_CopyTo(t *testing.T) { + ms := NewExportPartialSuccess() + orig := NewExportPartialSuccess() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + orig = generateTestExportPartialSuccess() + orig.CopyTo(ms) + assert.Equal(t, orig, ms) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + ms.CopyTo(newExportPartialSuccess(&otlpcollectorentity.ExportEntitiesPartialSuccess{}, &sharedState)) + }) +} + +func TestExportPartialSuccess_RejectedEntities(t *testing.T) { + ms := NewExportPartialSuccess() + assert.Equal(t, int64(0), ms.RejectedEntities()) + ms.SetRejectedEntities(int64(13)) + assert.Equal(t, int64(13), ms.RejectedEntities()) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + newExportPartialSuccess(&otlpcollectorentity.ExportEntitiesPartialSuccess{}, &sharedState).SetRejectedEntities(int64(13)) + }) +} + +func TestExportPartialSuccess_ErrorMessage(t *testing.T) { + ms := NewExportPartialSuccess() + assert.Equal(t, "", ms.ErrorMessage()) + ms.SetErrorMessage("error message") + assert.Equal(t, "error message", ms.ErrorMessage()) + sharedState := internal.StateReadOnly + assert.Panics(t, func() { + newExportPartialSuccess(&otlpcollectorentity.ExportEntitiesPartialSuccess{}, &sharedState).SetErrorMessage("error message") + }) +} + +func generateTestExportPartialSuccess() ExportPartialSuccess { + tv := NewExportPartialSuccess() + fillTestExportPartialSuccess(tv) + return tv +} + +func fillTestExportPartialSuccess(tv ExportPartialSuccess) { + tv.orig.RejectedEntities = int64(13) + tv.orig.ErrorMessage = "error message" +} diff --git a/pdata/plog/generated_logrecord.go b/pdata/plog/generated_logrecord.go index 5e9984a244c..ae87543259e 100644 --- a/pdata/plog/generated_logrecord.go +++ b/pdata/plog/generated_logrecord.go @@ -47,6 +47,14 @@ func (ms LogRecord) MoveTo(dest LogRecord) { *ms.orig = otlplogs.LogRecord{} } +func (ms LogRecord) getOrig() *otlplogs.LogRecord { + return ms.orig +} + +func (ms LogRecord) getState() *internal.State { + return ms.state +} + // ObservedTimestamp returns the observedtimestamp associated with this LogRecord. func (ms LogRecord) ObservedTimestamp() pcommon.Timestamp { return pcommon.Timestamp(ms.orig.ObservedTimeUnixNano) diff --git a/pdata/plog/generated_logrecordslice.go b/pdata/plog/generated_logrecordslice.go index a900b4e1c7e..f239d35191e 100644 --- a/pdata/plog/generated_logrecordslice.go +++ b/pdata/plog/generated_logrecordslice.go @@ -29,6 +29,14 @@ func newLogRecordSlice(orig *[]*otlplogs.LogRecord, state *internal.State) LogRe return LogRecordSlice{orig: orig, state: state} } +func (ms LogRecordSlice) getOrig() *[]*otlplogs.LogRecord { + return ms.orig +} + +func (ms LogRecordSlice) getState() *internal.State { + return ms.state +} + // NewLogRecordSlice creates a LogRecordSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewLogRecordSlice() LogRecordSlice { @@ -41,7 +49,7 @@ func NewLogRecordSlice() LogRecordSlice { // // Returns "0" for a newly instance created with "NewLogRecordSlice()". func (es LogRecordSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es LogRecordSlice) Len() int { // ... // Do something with the element // } func (es LogRecordSlice) At(i int) LogRecord { - return newLogRecord((*es.orig)[i], es.state) + return newLogRecord((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es LogRecordSlice) At(i int) LogRecord { // // Here should set all the values for e. // } func (es LogRecordSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlplogs.LogRecord, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlplogs.LogRecord, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty LogRecord. // It returns the newly added LogRecord. func (es LogRecordSlice) AppendEmpty() LogRecord { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlplogs.LogRecord{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlplogs.LogRecord{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es LogRecordSlice) MoveAndAppendTo(dest LogRecordSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es LogRecordSlice) RemoveIf(f func(LogRecord) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es LogRecordSlice) RemoveIf(f func(LogRecord) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es LogRecordSlice) CopyTo(dest LogRecordSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newLogRecord((*es.orig)[i], es.state).CopyTo(newLogRecord((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newLogRecord((*es.getOrig())[i], es.getState()).CopyTo(newLogRecord((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlplogs.LogRecord, srcLen) wrappers := make([]*otlplogs.LogRecord, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newLogRecord((*es.orig)[i], es.state).CopyTo(newLogRecord(wrappers[i], dest.state)) + newLogRecord((*es.getOrig())[i], es.getState()).CopyTo(newLogRecord(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the LogRecord elements within LogRecordSlice given the // provided less function so that two instances of LogRecordSlice // can be compared. func (es LogRecordSlice) Sort(less func(a, b LogRecord) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/plog/generated_logrecordslice_test.go b/pdata/plog/generated_logrecordslice_test.go index d8f6b5345fb..5e9c32400c2 100644 --- a/pdata/plog/generated_logrecordslice_test.go +++ b/pdata/plog/generated_logrecordslice_test.go @@ -69,14 +69,14 @@ func TestLogRecordSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestLogRecordSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestLogRecordSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestLogRecordSlice(), es) } @@ -126,16 +126,16 @@ func TestLogRecordSlice_RemoveIf(t *testing.T) { func TestLogRecordSlice_Sort(t *testing.T) { es := generateTestLogRecordSlice() es.Sort(func(a, b LogRecord) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b LogRecord) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/plog/generated_resourcelogs.go b/pdata/plog/generated_resourcelogs.go index 1d240e03975..4b420a65a08 100644 --- a/pdata/plog/generated_resourcelogs.go +++ b/pdata/plog/generated_resourcelogs.go @@ -46,6 +46,14 @@ func (ms ResourceLogs) MoveTo(dest ResourceLogs) { *ms.orig = otlplogs.ResourceLogs{} } +func (ms ResourceLogs) getOrig() *otlplogs.ResourceLogs { + return ms.orig +} + +func (ms ResourceLogs) getState() *internal.State { + return ms.state +} + // Resource returns the resource associated with this ResourceLogs. func (ms ResourceLogs) Resource() pcommon.Resource { return pcommon.Resource(internal.NewResource(&ms.orig.Resource, ms.state)) diff --git a/pdata/plog/generated_resourcelogsslice.go b/pdata/plog/generated_resourcelogsslice.go index d2fc54de80b..0195f4479db 100644 --- a/pdata/plog/generated_resourcelogsslice.go +++ b/pdata/plog/generated_resourcelogsslice.go @@ -29,6 +29,14 @@ func newResourceLogsSlice(orig *[]*otlplogs.ResourceLogs, state *internal.State) return ResourceLogsSlice{orig: orig, state: state} } +func (ms ResourceLogsSlice) getOrig() *[]*otlplogs.ResourceLogs { + return ms.orig +} + +func (ms ResourceLogsSlice) getState() *internal.State { + return ms.state +} + // NewResourceLogsSlice creates a ResourceLogsSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewResourceLogsSlice() ResourceLogsSlice { @@ -41,7 +49,7 @@ func NewResourceLogsSlice() ResourceLogsSlice { // // Returns "0" for a newly instance created with "NewResourceLogsSlice()". func (es ResourceLogsSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ResourceLogsSlice) Len() int { // ... // Do something with the element // } func (es ResourceLogsSlice) At(i int) ResourceLogs { - return newResourceLogs((*es.orig)[i], es.state) + return newResourceLogs((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ResourceLogsSlice) At(i int) ResourceLogs { // // Here should set all the values for e. // } func (es ResourceLogsSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlplogs.ResourceLogs, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlplogs.ResourceLogs, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ResourceLogs. // It returns the newly added ResourceLogs. func (es ResourceLogsSlice) AppendEmpty() ResourceLogs { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlplogs.ResourceLogs{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlplogs.ResourceLogs{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ResourceLogsSlice) MoveAndAppendTo(dest ResourceLogsSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ResourceLogsSlice) RemoveIf(f func(ResourceLogs) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ResourceLogsSlice) RemoveIf(f func(ResourceLogs) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ResourceLogsSlice) CopyTo(dest ResourceLogsSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newResourceLogs((*es.orig)[i], es.state).CopyTo(newResourceLogs((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newResourceLogs((*es.getOrig())[i], es.getState()).CopyTo(newResourceLogs((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlplogs.ResourceLogs, srcLen) wrappers := make([]*otlplogs.ResourceLogs, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newResourceLogs((*es.orig)[i], es.state).CopyTo(newResourceLogs(wrappers[i], dest.state)) + newResourceLogs((*es.getOrig())[i], es.getState()).CopyTo(newResourceLogs(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ResourceLogs elements within ResourceLogsSlice given the // provided less function so that two instances of ResourceLogsSlice // can be compared. func (es ResourceLogsSlice) Sort(less func(a, b ResourceLogs) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/plog/generated_resourcelogsslice_test.go b/pdata/plog/generated_resourcelogsslice_test.go index 3505ba5376a..9282c26faef 100644 --- a/pdata/plog/generated_resourcelogsslice_test.go +++ b/pdata/plog/generated_resourcelogsslice_test.go @@ -69,14 +69,14 @@ func TestResourceLogsSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestResourceLogsSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestResourceLogsSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestResourceLogsSlice(), es) } @@ -126,16 +126,16 @@ func TestResourceLogsSlice_RemoveIf(t *testing.T) { func TestResourceLogsSlice_Sort(t *testing.T) { es := generateTestResourceLogsSlice() es.Sort(func(a, b ResourceLogs) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ResourceLogs) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/plog/generated_scopelogs.go b/pdata/plog/generated_scopelogs.go index 6e45a9627f8..022d9aa0c71 100644 --- a/pdata/plog/generated_scopelogs.go +++ b/pdata/plog/generated_scopelogs.go @@ -46,6 +46,14 @@ func (ms ScopeLogs) MoveTo(dest ScopeLogs) { *ms.orig = otlplogs.ScopeLogs{} } +func (ms ScopeLogs) getOrig() *otlplogs.ScopeLogs { + return ms.orig +} + +func (ms ScopeLogs) getState() *internal.State { + return ms.state +} + // Scope returns the scope associated with this ScopeLogs. func (ms ScopeLogs) Scope() pcommon.InstrumentationScope { return pcommon.InstrumentationScope(internal.NewInstrumentationScope(&ms.orig.Scope, ms.state)) diff --git a/pdata/plog/generated_scopelogsslice.go b/pdata/plog/generated_scopelogsslice.go index 5bae8d9f9c9..adc3ab4f3ed 100644 --- a/pdata/plog/generated_scopelogsslice.go +++ b/pdata/plog/generated_scopelogsslice.go @@ -29,6 +29,14 @@ func newScopeLogsSlice(orig *[]*otlplogs.ScopeLogs, state *internal.State) Scope return ScopeLogsSlice{orig: orig, state: state} } +func (ms ScopeLogsSlice) getOrig() *[]*otlplogs.ScopeLogs { + return ms.orig +} + +func (ms ScopeLogsSlice) getState() *internal.State { + return ms.state +} + // NewScopeLogsSlice creates a ScopeLogsSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewScopeLogsSlice() ScopeLogsSlice { @@ -41,7 +49,7 @@ func NewScopeLogsSlice() ScopeLogsSlice { // // Returns "0" for a newly instance created with "NewScopeLogsSlice()". func (es ScopeLogsSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ScopeLogsSlice) Len() int { // ... // Do something with the element // } func (es ScopeLogsSlice) At(i int) ScopeLogs { - return newScopeLogs((*es.orig)[i], es.state) + return newScopeLogs((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ScopeLogsSlice) At(i int) ScopeLogs { // // Here should set all the values for e. // } func (es ScopeLogsSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlplogs.ScopeLogs, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlplogs.ScopeLogs, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ScopeLogs. // It returns the newly added ScopeLogs. func (es ScopeLogsSlice) AppendEmpty() ScopeLogs { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlplogs.ScopeLogs{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlplogs.ScopeLogs{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ScopeLogsSlice) MoveAndAppendTo(dest ScopeLogsSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ScopeLogsSlice) RemoveIf(f func(ScopeLogs) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ScopeLogsSlice) RemoveIf(f func(ScopeLogs) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ScopeLogsSlice) CopyTo(dest ScopeLogsSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newScopeLogs((*es.orig)[i], es.state).CopyTo(newScopeLogs((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newScopeLogs((*es.getOrig())[i], es.getState()).CopyTo(newScopeLogs((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlplogs.ScopeLogs, srcLen) wrappers := make([]*otlplogs.ScopeLogs, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newScopeLogs((*es.orig)[i], es.state).CopyTo(newScopeLogs(wrappers[i], dest.state)) + newScopeLogs((*es.getOrig())[i], es.getState()).CopyTo(newScopeLogs(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ScopeLogs elements within ScopeLogsSlice given the // provided less function so that two instances of ScopeLogsSlice // can be compared. func (es ScopeLogsSlice) Sort(less func(a, b ScopeLogs) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/plog/generated_scopelogsslice_test.go b/pdata/plog/generated_scopelogsslice_test.go index 6c599906449..a1d816ff4ba 100644 --- a/pdata/plog/generated_scopelogsslice_test.go +++ b/pdata/plog/generated_scopelogsslice_test.go @@ -69,14 +69,14 @@ func TestScopeLogsSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestScopeLogsSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestScopeLogsSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestScopeLogsSlice(), es) } @@ -126,16 +126,16 @@ func TestScopeLogsSlice_RemoveIf(t *testing.T) { func TestScopeLogsSlice_Sort(t *testing.T) { es := generateTestScopeLogsSlice() es.Sort(func(a, b ScopeLogs) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ScopeLogs) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/plog/plogotlp/generated_exportpartialsuccess.go b/pdata/plog/plogotlp/generated_exportpartialsuccess.go index bcf420c9120..5c20cc875e4 100644 --- a/pdata/plog/plogotlp/generated_exportpartialsuccess.go +++ b/pdata/plog/plogotlp/generated_exportpartialsuccess.go @@ -45,6 +45,14 @@ func (ms ExportPartialSuccess) MoveTo(dest ExportPartialSuccess) { *ms.orig = otlpcollectorlog.ExportLogsPartialSuccess{} } +func (ms ExportPartialSuccess) getOrig() *otlpcollectorlog.ExportLogsPartialSuccess { + return ms.orig +} + +func (ms ExportPartialSuccess) getState() *internal.State { + return ms.state +} + // RejectedLogRecords returns the rejectedlogrecords associated with this ExportPartialSuccess. func (ms ExportPartialSuccess) RejectedLogRecords() int64 { return ms.orig.RejectedLogRecords diff --git a/pdata/pmetric/generated_exemplar.go b/pdata/pmetric/generated_exemplar.go index 9937a1b500f..ebf33f2a486 100644 --- a/pdata/pmetric/generated_exemplar.go +++ b/pdata/pmetric/generated_exemplar.go @@ -50,6 +50,14 @@ func (ms Exemplar) MoveTo(dest Exemplar) { *ms.orig = otlpmetrics.Exemplar{} } +func (ms Exemplar) getOrig() *otlpmetrics.Exemplar { + return ms.orig +} + +func (ms Exemplar) getState() *internal.State { + return ms.state +} + // Timestamp returns the timestamp associated with this Exemplar. func (ms Exemplar) Timestamp() pcommon.Timestamp { return pcommon.Timestamp(ms.orig.TimeUnixNano) diff --git a/pdata/pmetric/generated_exemplarslice.go b/pdata/pmetric/generated_exemplarslice.go index 15d70a6edeb..a904aa217e5 100644 --- a/pdata/pmetric/generated_exemplarslice.go +++ b/pdata/pmetric/generated_exemplarslice.go @@ -27,6 +27,14 @@ func newExemplarSlice(orig *[]otlpmetrics.Exemplar, state *internal.State) Exemp return ExemplarSlice{orig: orig, state: state} } +func (ms ExemplarSlice) getOrig() *[]otlpmetrics.Exemplar { + return ms.orig +} + +func (ms ExemplarSlice) getState() *internal.State { + return ms.state +} + // NewExemplarSlice creates a ExemplarSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewExemplarSlice() ExemplarSlice { @@ -39,7 +47,7 @@ func NewExemplarSlice() ExemplarSlice { // // Returns "0" for a newly instance created with "NewExemplarSlice()". func (es ExemplarSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es ExemplarSlice) Len() int { // ... // Do something with the element // } func (es ExemplarSlice) At(i int) Exemplar { - return newExemplar(&(*es.orig)[i], es.state) + return newExemplar(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es ExemplarSlice) At(i int) Exemplar { // // Here should set all the values for e. // } func (es ExemplarSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpmetrics.Exemplar, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpmetrics.Exemplar, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Exemplar. // It returns the newly added Exemplar. func (es ExemplarSlice) AppendEmpty() Exemplar { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpmetrics.Exemplar{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpmetrics.Exemplar{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ExemplarSlice) MoveAndAppendTo(dest ExemplarSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ExemplarSlice) RemoveIf(f func(Exemplar) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es ExemplarSlice) RemoveIf(f func(Exemplar) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ExemplarSlice) CopyTo(dest ExemplarSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpmetrics.Exemplar, srcLen) + (*dest.getOrig()) = make([]otlpmetrics.Exemplar, srcLen) } - for i := range *es.orig { - newExemplar(&(*es.orig)[i], es.state).CopyTo(newExemplar(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newExemplar(&(*es.getOrig())[i], es.getState()).CopyTo(newExemplar(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pmetric/generated_exemplarslice_test.go b/pdata/pmetric/generated_exemplarslice_test.go index 7cda639f638..d5bf7728a29 100644 --- a/pdata/pmetric/generated_exemplarslice_test.go +++ b/pdata/pmetric/generated_exemplarslice_test.go @@ -68,14 +68,14 @@ func TestExemplarSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestExemplarSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestExemplarSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestExemplarSlice(), es) } diff --git a/pdata/pmetric/generated_exponentialhistogram.go b/pdata/pmetric/generated_exponentialhistogram.go index 18ba20d7377..5311768c5ea 100644 --- a/pdata/pmetric/generated_exponentialhistogram.go +++ b/pdata/pmetric/generated_exponentialhistogram.go @@ -46,6 +46,14 @@ func (ms ExponentialHistogram) MoveTo(dest ExponentialHistogram) { *ms.orig = otlpmetrics.ExponentialHistogram{} } +func (ms ExponentialHistogram) getOrig() *otlpmetrics.ExponentialHistogram { + return ms.orig +} + +func (ms ExponentialHistogram) getState() *internal.State { + return ms.state +} + // AggregationTemporality returns the aggregationtemporality associated with this ExponentialHistogram. func (ms ExponentialHistogram) AggregationTemporality() AggregationTemporality { return AggregationTemporality(ms.orig.AggregationTemporality) diff --git a/pdata/pmetric/generated_exponentialhistogramdatapoint.go b/pdata/pmetric/generated_exponentialhistogramdatapoint.go index 3d76368b384..3a86db1ee2f 100644 --- a/pdata/pmetric/generated_exponentialhistogramdatapoint.go +++ b/pdata/pmetric/generated_exponentialhistogramdatapoint.go @@ -49,6 +49,14 @@ func (ms ExponentialHistogramDataPoint) MoveTo(dest ExponentialHistogramDataPoin *ms.orig = otlpmetrics.ExponentialHistogramDataPoint{} } +func (ms ExponentialHistogramDataPoint) getOrig() *otlpmetrics.ExponentialHistogramDataPoint { + return ms.orig +} + +func (ms ExponentialHistogramDataPoint) getState() *internal.State { + return ms.state +} + // Attributes returns the Attributes associated with this ExponentialHistogramDataPoint. func (ms ExponentialHistogramDataPoint) Attributes() pcommon.Map { return pcommon.Map(internal.NewMap(&ms.orig.Attributes, ms.state)) diff --git a/pdata/pmetric/generated_exponentialhistogramdatapointbuckets.go b/pdata/pmetric/generated_exponentialhistogramdatapointbuckets.go index 7acfbc627f3..768fd47388d 100644 --- a/pdata/pmetric/generated_exponentialhistogramdatapointbuckets.go +++ b/pdata/pmetric/generated_exponentialhistogramdatapointbuckets.go @@ -46,6 +46,14 @@ func (ms ExponentialHistogramDataPointBuckets) MoveTo(dest ExponentialHistogramD *ms.orig = otlpmetrics.ExponentialHistogramDataPoint_Buckets{} } +func (ms ExponentialHistogramDataPointBuckets) getOrig() *otlpmetrics.ExponentialHistogramDataPoint_Buckets { + return ms.orig +} + +func (ms ExponentialHistogramDataPointBuckets) getState() *internal.State { + return ms.state +} + // Offset returns the offset associated with this ExponentialHistogramDataPointBuckets. func (ms ExponentialHistogramDataPointBuckets) Offset() int32 { return ms.orig.Offset diff --git a/pdata/pmetric/generated_exponentialhistogramdatapointslice.go b/pdata/pmetric/generated_exponentialhistogramdatapointslice.go index a466a7c185b..35d73fd0a98 100644 --- a/pdata/pmetric/generated_exponentialhistogramdatapointslice.go +++ b/pdata/pmetric/generated_exponentialhistogramdatapointslice.go @@ -29,6 +29,14 @@ func newExponentialHistogramDataPointSlice(orig *[]*otlpmetrics.ExponentialHisto return ExponentialHistogramDataPointSlice{orig: orig, state: state} } +func (ms ExponentialHistogramDataPointSlice) getOrig() *[]*otlpmetrics.ExponentialHistogramDataPoint { + return ms.orig +} + +func (ms ExponentialHistogramDataPointSlice) getState() *internal.State { + return ms.state +} + // NewExponentialHistogramDataPointSlice creates a ExponentialHistogramDataPointSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewExponentialHistogramDataPointSlice() ExponentialHistogramDataPointSlice { @@ -41,7 +49,7 @@ func NewExponentialHistogramDataPointSlice() ExponentialHistogramDataPointSlice // // Returns "0" for a newly instance created with "NewExponentialHistogramDataPointSlice()". func (es ExponentialHistogramDataPointSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ExponentialHistogramDataPointSlice) Len() int { // ... // Do something with the element // } func (es ExponentialHistogramDataPointSlice) At(i int) ExponentialHistogramDataPoint { - return newExponentialHistogramDataPoint((*es.orig)[i], es.state) + return newExponentialHistogramDataPoint((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ExponentialHistogramDataPointSlice) At(i int) ExponentialHistogramDataP // // Here should set all the values for e. // } func (es ExponentialHistogramDataPointSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpmetrics.ExponentialHistogramDataPoint, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpmetrics.ExponentialHistogramDataPoint, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ExponentialHistogramDataPoint. // It returns the newly added ExponentialHistogramDataPoint. func (es ExponentialHistogramDataPointSlice) AppendEmpty() ExponentialHistogramDataPoint { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpmetrics.ExponentialHistogramDataPoint{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpmetrics.ExponentialHistogramDataPoint{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ExponentialHistogramDataPointSlice) MoveAndAppendTo(dest ExponentialHistogramDataPointSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ExponentialHistogramDataPointSlice) RemoveIf(f func(ExponentialHistogramDataPoint) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ExponentialHistogramDataPointSlice) RemoveIf(f func(ExponentialHistogra newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ExponentialHistogramDataPointSlice) CopyTo(dest ExponentialHistogramDataPointSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newExponentialHistogramDataPoint((*es.orig)[i], es.state).CopyTo(newExponentialHistogramDataPoint((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newExponentialHistogramDataPoint((*es.getOrig())[i], es.getState()).CopyTo(newExponentialHistogramDataPoint((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpmetrics.ExponentialHistogramDataPoint, srcLen) wrappers := make([]*otlpmetrics.ExponentialHistogramDataPoint, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newExponentialHistogramDataPoint((*es.orig)[i], es.state).CopyTo(newExponentialHistogramDataPoint(wrappers[i], dest.state)) + newExponentialHistogramDataPoint((*es.getOrig())[i], es.getState()).CopyTo(newExponentialHistogramDataPoint(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ExponentialHistogramDataPoint elements within ExponentialHistogramDataPointSlice given the // provided less function so that two instances of ExponentialHistogramDataPointSlice // can be compared. func (es ExponentialHistogramDataPointSlice) Sort(less func(a, b ExponentialHistogramDataPoint) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go b/pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go index 7367f854a3a..e9ab621f044 100644 --- a/pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go +++ b/pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go @@ -69,14 +69,14 @@ func TestExponentialHistogramDataPointSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestExponentialHistogramDataPointSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestExponentialHistogramDataPointSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestExponentialHistogramDataPointSlice(), es) } @@ -126,16 +126,16 @@ func TestExponentialHistogramDataPointSlice_RemoveIf(t *testing.T) { func TestExponentialHistogramDataPointSlice_Sort(t *testing.T) { es := generateTestExponentialHistogramDataPointSlice() es.Sort(func(a, b ExponentialHistogramDataPoint) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ExponentialHistogramDataPoint) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pmetric/generated_gauge.go b/pdata/pmetric/generated_gauge.go index ba572f9ca57..d5030dc6ae4 100644 --- a/pdata/pmetric/generated_gauge.go +++ b/pdata/pmetric/generated_gauge.go @@ -45,6 +45,14 @@ func (ms Gauge) MoveTo(dest Gauge) { *ms.orig = otlpmetrics.Gauge{} } +func (ms Gauge) getOrig() *otlpmetrics.Gauge { + return ms.orig +} + +func (ms Gauge) getState() *internal.State { + return ms.state +} + // DataPoints returns the DataPoints associated with this Gauge. func (ms Gauge) DataPoints() NumberDataPointSlice { return newNumberDataPointSlice(&ms.orig.DataPoints, ms.state) diff --git a/pdata/pmetric/generated_histogram.go b/pdata/pmetric/generated_histogram.go index 950fb13127e..d3527acbae0 100644 --- a/pdata/pmetric/generated_histogram.go +++ b/pdata/pmetric/generated_histogram.go @@ -45,6 +45,14 @@ func (ms Histogram) MoveTo(dest Histogram) { *ms.orig = otlpmetrics.Histogram{} } +func (ms Histogram) getOrig() *otlpmetrics.Histogram { + return ms.orig +} + +func (ms Histogram) getState() *internal.State { + return ms.state +} + // AggregationTemporality returns the aggregationtemporality associated with this Histogram. func (ms Histogram) AggregationTemporality() AggregationTemporality { return AggregationTemporality(ms.orig.AggregationTemporality) diff --git a/pdata/pmetric/generated_histogramdatapoint.go b/pdata/pmetric/generated_histogramdatapoint.go index 22dc32344a2..d4912c58038 100644 --- a/pdata/pmetric/generated_histogramdatapoint.go +++ b/pdata/pmetric/generated_histogramdatapoint.go @@ -46,6 +46,14 @@ func (ms HistogramDataPoint) MoveTo(dest HistogramDataPoint) { *ms.orig = otlpmetrics.HistogramDataPoint{} } +func (ms HistogramDataPoint) getOrig() *otlpmetrics.HistogramDataPoint { + return ms.orig +} + +func (ms HistogramDataPoint) getState() *internal.State { + return ms.state +} + // Attributes returns the Attributes associated with this HistogramDataPoint. func (ms HistogramDataPoint) Attributes() pcommon.Map { return pcommon.Map(internal.NewMap(&ms.orig.Attributes, ms.state)) diff --git a/pdata/pmetric/generated_histogramdatapointslice.go b/pdata/pmetric/generated_histogramdatapointslice.go index 7ee6ef737f8..0ef71f0ad83 100644 --- a/pdata/pmetric/generated_histogramdatapointslice.go +++ b/pdata/pmetric/generated_histogramdatapointslice.go @@ -29,6 +29,14 @@ func newHistogramDataPointSlice(orig *[]*otlpmetrics.HistogramDataPoint, state * return HistogramDataPointSlice{orig: orig, state: state} } +func (ms HistogramDataPointSlice) getOrig() *[]*otlpmetrics.HistogramDataPoint { + return ms.orig +} + +func (ms HistogramDataPointSlice) getState() *internal.State { + return ms.state +} + // NewHistogramDataPointSlice creates a HistogramDataPointSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewHistogramDataPointSlice() HistogramDataPointSlice { @@ -41,7 +49,7 @@ func NewHistogramDataPointSlice() HistogramDataPointSlice { // // Returns "0" for a newly instance created with "NewHistogramDataPointSlice()". func (es HistogramDataPointSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es HistogramDataPointSlice) Len() int { // ... // Do something with the element // } func (es HistogramDataPointSlice) At(i int) HistogramDataPoint { - return newHistogramDataPoint((*es.orig)[i], es.state) + return newHistogramDataPoint((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es HistogramDataPointSlice) At(i int) HistogramDataPoint { // // Here should set all the values for e. // } func (es HistogramDataPointSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpmetrics.HistogramDataPoint, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpmetrics.HistogramDataPoint, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty HistogramDataPoint. // It returns the newly added HistogramDataPoint. func (es HistogramDataPointSlice) AppendEmpty() HistogramDataPoint { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpmetrics.HistogramDataPoint{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpmetrics.HistogramDataPoint{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es HistogramDataPointSlice) MoveAndAppendTo(dest HistogramDataPointSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es HistogramDataPointSlice) RemoveIf(f func(HistogramDataPoint) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es HistogramDataPointSlice) RemoveIf(f func(HistogramDataPoint) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es HistogramDataPointSlice) CopyTo(dest HistogramDataPointSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newHistogramDataPoint((*es.orig)[i], es.state).CopyTo(newHistogramDataPoint((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newHistogramDataPoint((*es.getOrig())[i], es.getState()).CopyTo(newHistogramDataPoint((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpmetrics.HistogramDataPoint, srcLen) wrappers := make([]*otlpmetrics.HistogramDataPoint, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newHistogramDataPoint((*es.orig)[i], es.state).CopyTo(newHistogramDataPoint(wrappers[i], dest.state)) + newHistogramDataPoint((*es.getOrig())[i], es.getState()).CopyTo(newHistogramDataPoint(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the HistogramDataPoint elements within HistogramDataPointSlice given the // provided less function so that two instances of HistogramDataPointSlice // can be compared. func (es HistogramDataPointSlice) Sort(less func(a, b HistogramDataPoint) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pmetric/generated_histogramdatapointslice_test.go b/pdata/pmetric/generated_histogramdatapointslice_test.go index 14a4cd95c0c..0a172eb3160 100644 --- a/pdata/pmetric/generated_histogramdatapointslice_test.go +++ b/pdata/pmetric/generated_histogramdatapointslice_test.go @@ -69,14 +69,14 @@ func TestHistogramDataPointSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestHistogramDataPointSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestHistogramDataPointSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestHistogramDataPointSlice(), es) } @@ -126,16 +126,16 @@ func TestHistogramDataPointSlice_RemoveIf(t *testing.T) { func TestHistogramDataPointSlice_Sort(t *testing.T) { es := generateTestHistogramDataPointSlice() es.Sort(func(a, b HistogramDataPoint) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b HistogramDataPoint) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pmetric/generated_metric.go b/pdata/pmetric/generated_metric.go index ecf2dba29ef..33eff75bbe0 100644 --- a/pdata/pmetric/generated_metric.go +++ b/pdata/pmetric/generated_metric.go @@ -47,6 +47,14 @@ func (ms Metric) MoveTo(dest Metric) { *ms.orig = otlpmetrics.Metric{} } +func (ms Metric) getOrig() *otlpmetrics.Metric { + return ms.orig +} + +func (ms Metric) getState() *internal.State { + return ms.state +} + // Name returns the name associated with this Metric. func (ms Metric) Name() string { return ms.orig.Name diff --git a/pdata/pmetric/generated_metricslice.go b/pdata/pmetric/generated_metricslice.go index 13f05a0ecbc..196b7410649 100644 --- a/pdata/pmetric/generated_metricslice.go +++ b/pdata/pmetric/generated_metricslice.go @@ -29,6 +29,14 @@ func newMetricSlice(orig *[]*otlpmetrics.Metric, state *internal.State) MetricSl return MetricSlice{orig: orig, state: state} } +func (ms MetricSlice) getOrig() *[]*otlpmetrics.Metric { + return ms.orig +} + +func (ms MetricSlice) getState() *internal.State { + return ms.state +} + // NewMetricSlice creates a MetricSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewMetricSlice() MetricSlice { @@ -41,7 +49,7 @@ func NewMetricSlice() MetricSlice { // // Returns "0" for a newly instance created with "NewMetricSlice()". func (es MetricSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es MetricSlice) Len() int { // ... // Do something with the element // } func (es MetricSlice) At(i int) Metric { - return newMetric((*es.orig)[i], es.state) + return newMetric((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es MetricSlice) At(i int) Metric { // // Here should set all the values for e. // } func (es MetricSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpmetrics.Metric, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpmetrics.Metric, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Metric. // It returns the newly added Metric. func (es MetricSlice) AppendEmpty() Metric { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpmetrics.Metric{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpmetrics.Metric{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es MetricSlice) MoveAndAppendTo(dest MetricSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es MetricSlice) RemoveIf(f func(Metric) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es MetricSlice) RemoveIf(f func(Metric) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es MetricSlice) CopyTo(dest MetricSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newMetric((*es.orig)[i], es.state).CopyTo(newMetric((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newMetric((*es.getOrig())[i], es.getState()).CopyTo(newMetric((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpmetrics.Metric, srcLen) wrappers := make([]*otlpmetrics.Metric, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newMetric((*es.orig)[i], es.state).CopyTo(newMetric(wrappers[i], dest.state)) + newMetric((*es.getOrig())[i], es.getState()).CopyTo(newMetric(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the Metric elements within MetricSlice given the // provided less function so that two instances of MetricSlice // can be compared. func (es MetricSlice) Sort(less func(a, b Metric) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pmetric/generated_metricslice_test.go b/pdata/pmetric/generated_metricslice_test.go index ecd625e9dac..330b2304863 100644 --- a/pdata/pmetric/generated_metricslice_test.go +++ b/pdata/pmetric/generated_metricslice_test.go @@ -69,14 +69,14 @@ func TestMetricSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestMetricSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestMetricSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestMetricSlice(), es) } @@ -126,16 +126,16 @@ func TestMetricSlice_RemoveIf(t *testing.T) { func TestMetricSlice_Sort(t *testing.T) { es := generateTestMetricSlice() es.Sort(func(a, b Metric) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b Metric) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pmetric/generated_numberdatapoint.go b/pdata/pmetric/generated_numberdatapoint.go index bc47c4747d1..1f1c19742b9 100644 --- a/pdata/pmetric/generated_numberdatapoint.go +++ b/pdata/pmetric/generated_numberdatapoint.go @@ -46,6 +46,14 @@ func (ms NumberDataPoint) MoveTo(dest NumberDataPoint) { *ms.orig = otlpmetrics.NumberDataPoint{} } +func (ms NumberDataPoint) getOrig() *otlpmetrics.NumberDataPoint { + return ms.orig +} + +func (ms NumberDataPoint) getState() *internal.State { + return ms.state +} + // Attributes returns the Attributes associated with this NumberDataPoint. func (ms NumberDataPoint) Attributes() pcommon.Map { return pcommon.Map(internal.NewMap(&ms.orig.Attributes, ms.state)) diff --git a/pdata/pmetric/generated_numberdatapointslice.go b/pdata/pmetric/generated_numberdatapointslice.go index 57cdd11743e..32dc1b3a28e 100644 --- a/pdata/pmetric/generated_numberdatapointslice.go +++ b/pdata/pmetric/generated_numberdatapointslice.go @@ -29,6 +29,14 @@ func newNumberDataPointSlice(orig *[]*otlpmetrics.NumberDataPoint, state *intern return NumberDataPointSlice{orig: orig, state: state} } +func (ms NumberDataPointSlice) getOrig() *[]*otlpmetrics.NumberDataPoint { + return ms.orig +} + +func (ms NumberDataPointSlice) getState() *internal.State { + return ms.state +} + // NewNumberDataPointSlice creates a NumberDataPointSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewNumberDataPointSlice() NumberDataPointSlice { @@ -41,7 +49,7 @@ func NewNumberDataPointSlice() NumberDataPointSlice { // // Returns "0" for a newly instance created with "NewNumberDataPointSlice()". func (es NumberDataPointSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es NumberDataPointSlice) Len() int { // ... // Do something with the element // } func (es NumberDataPointSlice) At(i int) NumberDataPoint { - return newNumberDataPoint((*es.orig)[i], es.state) + return newNumberDataPoint((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es NumberDataPointSlice) At(i int) NumberDataPoint { // // Here should set all the values for e. // } func (es NumberDataPointSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpmetrics.NumberDataPoint, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpmetrics.NumberDataPoint, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty NumberDataPoint. // It returns the newly added NumberDataPoint. func (es NumberDataPointSlice) AppendEmpty() NumberDataPoint { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpmetrics.NumberDataPoint{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpmetrics.NumberDataPoint{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es NumberDataPointSlice) MoveAndAppendTo(dest NumberDataPointSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es NumberDataPointSlice) RemoveIf(f func(NumberDataPoint) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es NumberDataPointSlice) RemoveIf(f func(NumberDataPoint) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es NumberDataPointSlice) CopyTo(dest NumberDataPointSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newNumberDataPoint((*es.orig)[i], es.state).CopyTo(newNumberDataPoint((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newNumberDataPoint((*es.getOrig())[i], es.getState()).CopyTo(newNumberDataPoint((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpmetrics.NumberDataPoint, srcLen) wrappers := make([]*otlpmetrics.NumberDataPoint, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newNumberDataPoint((*es.orig)[i], es.state).CopyTo(newNumberDataPoint(wrappers[i], dest.state)) + newNumberDataPoint((*es.getOrig())[i], es.getState()).CopyTo(newNumberDataPoint(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the NumberDataPoint elements within NumberDataPointSlice given the // provided less function so that two instances of NumberDataPointSlice // can be compared. func (es NumberDataPointSlice) Sort(less func(a, b NumberDataPoint) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pmetric/generated_numberdatapointslice_test.go b/pdata/pmetric/generated_numberdatapointslice_test.go index e431fc4b0e2..f22f3601573 100644 --- a/pdata/pmetric/generated_numberdatapointslice_test.go +++ b/pdata/pmetric/generated_numberdatapointslice_test.go @@ -69,14 +69,14 @@ func TestNumberDataPointSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestNumberDataPointSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestNumberDataPointSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestNumberDataPointSlice(), es) } @@ -126,16 +126,16 @@ func TestNumberDataPointSlice_RemoveIf(t *testing.T) { func TestNumberDataPointSlice_Sort(t *testing.T) { es := generateTestNumberDataPointSlice() es.Sort(func(a, b NumberDataPoint) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b NumberDataPoint) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pmetric/generated_resourcemetrics.go b/pdata/pmetric/generated_resourcemetrics.go index 43622f3f806..0c0489187e2 100644 --- a/pdata/pmetric/generated_resourcemetrics.go +++ b/pdata/pmetric/generated_resourcemetrics.go @@ -46,6 +46,14 @@ func (ms ResourceMetrics) MoveTo(dest ResourceMetrics) { *ms.orig = otlpmetrics.ResourceMetrics{} } +func (ms ResourceMetrics) getOrig() *otlpmetrics.ResourceMetrics { + return ms.orig +} + +func (ms ResourceMetrics) getState() *internal.State { + return ms.state +} + // Resource returns the resource associated with this ResourceMetrics. func (ms ResourceMetrics) Resource() pcommon.Resource { return pcommon.Resource(internal.NewResource(&ms.orig.Resource, ms.state)) diff --git a/pdata/pmetric/generated_resourcemetricsslice.go b/pdata/pmetric/generated_resourcemetricsslice.go index 55217ea27d5..3b18866ecc1 100644 --- a/pdata/pmetric/generated_resourcemetricsslice.go +++ b/pdata/pmetric/generated_resourcemetricsslice.go @@ -29,6 +29,14 @@ func newResourceMetricsSlice(orig *[]*otlpmetrics.ResourceMetrics, state *intern return ResourceMetricsSlice{orig: orig, state: state} } +func (ms ResourceMetricsSlice) getOrig() *[]*otlpmetrics.ResourceMetrics { + return ms.orig +} + +func (ms ResourceMetricsSlice) getState() *internal.State { + return ms.state +} + // NewResourceMetricsSlice creates a ResourceMetricsSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewResourceMetricsSlice() ResourceMetricsSlice { @@ -41,7 +49,7 @@ func NewResourceMetricsSlice() ResourceMetricsSlice { // // Returns "0" for a newly instance created with "NewResourceMetricsSlice()". func (es ResourceMetricsSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ResourceMetricsSlice) Len() int { // ... // Do something with the element // } func (es ResourceMetricsSlice) At(i int) ResourceMetrics { - return newResourceMetrics((*es.orig)[i], es.state) + return newResourceMetrics((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ResourceMetricsSlice) At(i int) ResourceMetrics { // // Here should set all the values for e. // } func (es ResourceMetricsSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpmetrics.ResourceMetrics, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpmetrics.ResourceMetrics, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ResourceMetrics. // It returns the newly added ResourceMetrics. func (es ResourceMetricsSlice) AppendEmpty() ResourceMetrics { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpmetrics.ResourceMetrics{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpmetrics.ResourceMetrics{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ResourceMetricsSlice) MoveAndAppendTo(dest ResourceMetricsSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ResourceMetricsSlice) RemoveIf(f func(ResourceMetrics) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ResourceMetricsSlice) RemoveIf(f func(ResourceMetrics) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ResourceMetricsSlice) CopyTo(dest ResourceMetricsSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newResourceMetrics((*es.orig)[i], es.state).CopyTo(newResourceMetrics((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newResourceMetrics((*es.getOrig())[i], es.getState()).CopyTo(newResourceMetrics((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpmetrics.ResourceMetrics, srcLen) wrappers := make([]*otlpmetrics.ResourceMetrics, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newResourceMetrics((*es.orig)[i], es.state).CopyTo(newResourceMetrics(wrappers[i], dest.state)) + newResourceMetrics((*es.getOrig())[i], es.getState()).CopyTo(newResourceMetrics(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ResourceMetrics elements within ResourceMetricsSlice given the // provided less function so that two instances of ResourceMetricsSlice // can be compared. func (es ResourceMetricsSlice) Sort(less func(a, b ResourceMetrics) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pmetric/generated_resourcemetricsslice_test.go b/pdata/pmetric/generated_resourcemetricsslice_test.go index 41672b180c9..25c465d7610 100644 --- a/pdata/pmetric/generated_resourcemetricsslice_test.go +++ b/pdata/pmetric/generated_resourcemetricsslice_test.go @@ -69,14 +69,14 @@ func TestResourceMetricsSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestResourceMetricsSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestResourceMetricsSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestResourceMetricsSlice(), es) } @@ -126,16 +126,16 @@ func TestResourceMetricsSlice_RemoveIf(t *testing.T) { func TestResourceMetricsSlice_Sort(t *testing.T) { es := generateTestResourceMetricsSlice() es.Sort(func(a, b ResourceMetrics) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ResourceMetrics) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pmetric/generated_scopemetrics.go b/pdata/pmetric/generated_scopemetrics.go index 1151c36dae3..f94bc8640ee 100644 --- a/pdata/pmetric/generated_scopemetrics.go +++ b/pdata/pmetric/generated_scopemetrics.go @@ -46,6 +46,14 @@ func (ms ScopeMetrics) MoveTo(dest ScopeMetrics) { *ms.orig = otlpmetrics.ScopeMetrics{} } +func (ms ScopeMetrics) getOrig() *otlpmetrics.ScopeMetrics { + return ms.orig +} + +func (ms ScopeMetrics) getState() *internal.State { + return ms.state +} + // Scope returns the scope associated with this ScopeMetrics. func (ms ScopeMetrics) Scope() pcommon.InstrumentationScope { return pcommon.InstrumentationScope(internal.NewInstrumentationScope(&ms.orig.Scope, ms.state)) diff --git a/pdata/pmetric/generated_scopemetricsslice.go b/pdata/pmetric/generated_scopemetricsslice.go index a86eb0b4815..67d25c9d267 100644 --- a/pdata/pmetric/generated_scopemetricsslice.go +++ b/pdata/pmetric/generated_scopemetricsslice.go @@ -29,6 +29,14 @@ func newScopeMetricsSlice(orig *[]*otlpmetrics.ScopeMetrics, state *internal.Sta return ScopeMetricsSlice{orig: orig, state: state} } +func (ms ScopeMetricsSlice) getOrig() *[]*otlpmetrics.ScopeMetrics { + return ms.orig +} + +func (ms ScopeMetricsSlice) getState() *internal.State { + return ms.state +} + // NewScopeMetricsSlice creates a ScopeMetricsSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewScopeMetricsSlice() ScopeMetricsSlice { @@ -41,7 +49,7 @@ func NewScopeMetricsSlice() ScopeMetricsSlice { // // Returns "0" for a newly instance created with "NewScopeMetricsSlice()". func (es ScopeMetricsSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ScopeMetricsSlice) Len() int { // ... // Do something with the element // } func (es ScopeMetricsSlice) At(i int) ScopeMetrics { - return newScopeMetrics((*es.orig)[i], es.state) + return newScopeMetrics((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ScopeMetricsSlice) At(i int) ScopeMetrics { // // Here should set all the values for e. // } func (es ScopeMetricsSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpmetrics.ScopeMetrics, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpmetrics.ScopeMetrics, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ScopeMetrics. // It returns the newly added ScopeMetrics. func (es ScopeMetricsSlice) AppendEmpty() ScopeMetrics { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpmetrics.ScopeMetrics{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpmetrics.ScopeMetrics{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ScopeMetricsSlice) MoveAndAppendTo(dest ScopeMetricsSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ScopeMetricsSlice) RemoveIf(f func(ScopeMetrics) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ScopeMetricsSlice) RemoveIf(f func(ScopeMetrics) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ScopeMetricsSlice) CopyTo(dest ScopeMetricsSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newScopeMetrics((*es.orig)[i], es.state).CopyTo(newScopeMetrics((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newScopeMetrics((*es.getOrig())[i], es.getState()).CopyTo(newScopeMetrics((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpmetrics.ScopeMetrics, srcLen) wrappers := make([]*otlpmetrics.ScopeMetrics, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newScopeMetrics((*es.orig)[i], es.state).CopyTo(newScopeMetrics(wrappers[i], dest.state)) + newScopeMetrics((*es.getOrig())[i], es.getState()).CopyTo(newScopeMetrics(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ScopeMetrics elements within ScopeMetricsSlice given the // provided less function so that two instances of ScopeMetricsSlice // can be compared. func (es ScopeMetricsSlice) Sort(less func(a, b ScopeMetrics) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pmetric/generated_scopemetricsslice_test.go b/pdata/pmetric/generated_scopemetricsslice_test.go index 0374828d6b5..349014ac5df 100644 --- a/pdata/pmetric/generated_scopemetricsslice_test.go +++ b/pdata/pmetric/generated_scopemetricsslice_test.go @@ -69,14 +69,14 @@ func TestScopeMetricsSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestScopeMetricsSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestScopeMetricsSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestScopeMetricsSlice(), es) } @@ -126,16 +126,16 @@ func TestScopeMetricsSlice_RemoveIf(t *testing.T) { func TestScopeMetricsSlice_Sort(t *testing.T) { es := generateTestScopeMetricsSlice() es.Sort(func(a, b ScopeMetrics) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ScopeMetrics) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pmetric/generated_sum.go b/pdata/pmetric/generated_sum.go index 7def0749aa5..ec7df2db5c5 100644 --- a/pdata/pmetric/generated_sum.go +++ b/pdata/pmetric/generated_sum.go @@ -45,6 +45,14 @@ func (ms Sum) MoveTo(dest Sum) { *ms.orig = otlpmetrics.Sum{} } +func (ms Sum) getOrig() *otlpmetrics.Sum { + return ms.orig +} + +func (ms Sum) getState() *internal.State { + return ms.state +} + // AggregationTemporality returns the aggregationtemporality associated with this Sum. func (ms Sum) AggregationTemporality() AggregationTemporality { return AggregationTemporality(ms.orig.AggregationTemporality) diff --git a/pdata/pmetric/generated_summary.go b/pdata/pmetric/generated_summary.go index 64fbffbefd3..5346f5a1068 100644 --- a/pdata/pmetric/generated_summary.go +++ b/pdata/pmetric/generated_summary.go @@ -45,6 +45,14 @@ func (ms Summary) MoveTo(dest Summary) { *ms.orig = otlpmetrics.Summary{} } +func (ms Summary) getOrig() *otlpmetrics.Summary { + return ms.orig +} + +func (ms Summary) getState() *internal.State { + return ms.state +} + // DataPoints returns the DataPoints associated with this Summary. func (ms Summary) DataPoints() SummaryDataPointSlice { return newSummaryDataPointSlice(&ms.orig.DataPoints, ms.state) diff --git a/pdata/pmetric/generated_summarydatapoint.go b/pdata/pmetric/generated_summarydatapoint.go index 0f0f6dd1e99..eb1e3a50b2b 100644 --- a/pdata/pmetric/generated_summarydatapoint.go +++ b/pdata/pmetric/generated_summarydatapoint.go @@ -46,6 +46,14 @@ func (ms SummaryDataPoint) MoveTo(dest SummaryDataPoint) { *ms.orig = otlpmetrics.SummaryDataPoint{} } +func (ms SummaryDataPoint) getOrig() *otlpmetrics.SummaryDataPoint { + return ms.orig +} + +func (ms SummaryDataPoint) getState() *internal.State { + return ms.state +} + // Attributes returns the Attributes associated with this SummaryDataPoint. func (ms SummaryDataPoint) Attributes() pcommon.Map { return pcommon.Map(internal.NewMap(&ms.orig.Attributes, ms.state)) diff --git a/pdata/pmetric/generated_summarydatapointslice.go b/pdata/pmetric/generated_summarydatapointslice.go index f915500963f..3b03922c11e 100644 --- a/pdata/pmetric/generated_summarydatapointslice.go +++ b/pdata/pmetric/generated_summarydatapointslice.go @@ -29,6 +29,14 @@ func newSummaryDataPointSlice(orig *[]*otlpmetrics.SummaryDataPoint, state *inte return SummaryDataPointSlice{orig: orig, state: state} } +func (ms SummaryDataPointSlice) getOrig() *[]*otlpmetrics.SummaryDataPoint { + return ms.orig +} + +func (ms SummaryDataPointSlice) getState() *internal.State { + return ms.state +} + // NewSummaryDataPointSlice creates a SummaryDataPointSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewSummaryDataPointSlice() SummaryDataPointSlice { @@ -41,7 +49,7 @@ func NewSummaryDataPointSlice() SummaryDataPointSlice { // // Returns "0" for a newly instance created with "NewSummaryDataPointSlice()". func (es SummaryDataPointSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es SummaryDataPointSlice) Len() int { // ... // Do something with the element // } func (es SummaryDataPointSlice) At(i int) SummaryDataPoint { - return newSummaryDataPoint((*es.orig)[i], es.state) + return newSummaryDataPoint((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es SummaryDataPointSlice) At(i int) SummaryDataPoint { // // Here should set all the values for e. // } func (es SummaryDataPointSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpmetrics.SummaryDataPoint, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpmetrics.SummaryDataPoint, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty SummaryDataPoint. // It returns the newly added SummaryDataPoint. func (es SummaryDataPointSlice) AppendEmpty() SummaryDataPoint { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpmetrics.SummaryDataPoint{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpmetrics.SummaryDataPoint{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es SummaryDataPointSlice) MoveAndAppendTo(dest SummaryDataPointSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es SummaryDataPointSlice) RemoveIf(f func(SummaryDataPoint) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es SummaryDataPointSlice) RemoveIf(f func(SummaryDataPoint) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es SummaryDataPointSlice) CopyTo(dest SummaryDataPointSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newSummaryDataPoint((*es.orig)[i], es.state).CopyTo(newSummaryDataPoint((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newSummaryDataPoint((*es.getOrig())[i], es.getState()).CopyTo(newSummaryDataPoint((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpmetrics.SummaryDataPoint, srcLen) wrappers := make([]*otlpmetrics.SummaryDataPoint, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newSummaryDataPoint((*es.orig)[i], es.state).CopyTo(newSummaryDataPoint(wrappers[i], dest.state)) + newSummaryDataPoint((*es.getOrig())[i], es.getState()).CopyTo(newSummaryDataPoint(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the SummaryDataPoint elements within SummaryDataPointSlice given the // provided less function so that two instances of SummaryDataPointSlice // can be compared. func (es SummaryDataPointSlice) Sort(less func(a, b SummaryDataPoint) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pmetric/generated_summarydatapointslice_test.go b/pdata/pmetric/generated_summarydatapointslice_test.go index 2ebbe38c0bd..d9f886d9d4a 100644 --- a/pdata/pmetric/generated_summarydatapointslice_test.go +++ b/pdata/pmetric/generated_summarydatapointslice_test.go @@ -69,14 +69,14 @@ func TestSummaryDataPointSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestSummaryDataPointSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestSummaryDataPointSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestSummaryDataPointSlice(), es) } @@ -126,16 +126,16 @@ func TestSummaryDataPointSlice_RemoveIf(t *testing.T) { func TestSummaryDataPointSlice_Sort(t *testing.T) { es := generateTestSummaryDataPointSlice() es.Sort(func(a, b SummaryDataPoint) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b SummaryDataPoint) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pmetric/generated_summarydatapointvalueatquantile.go b/pdata/pmetric/generated_summarydatapointvalueatquantile.go index b4e1fe08f7b..833348ae70e 100644 --- a/pdata/pmetric/generated_summarydatapointvalueatquantile.go +++ b/pdata/pmetric/generated_summarydatapointvalueatquantile.go @@ -45,6 +45,14 @@ func (ms SummaryDataPointValueAtQuantile) MoveTo(dest SummaryDataPointValueAtQua *ms.orig = otlpmetrics.SummaryDataPoint_ValueAtQuantile{} } +func (ms SummaryDataPointValueAtQuantile) getOrig() *otlpmetrics.SummaryDataPoint_ValueAtQuantile { + return ms.orig +} + +func (ms SummaryDataPointValueAtQuantile) getState() *internal.State { + return ms.state +} + // Quantile returns the quantile associated with this SummaryDataPointValueAtQuantile. func (ms SummaryDataPointValueAtQuantile) Quantile() float64 { return ms.orig.Quantile diff --git a/pdata/pmetric/generated_summarydatapointvalueatquantileslice.go b/pdata/pmetric/generated_summarydatapointvalueatquantileslice.go index ed899050ac6..b672b63bd8d 100644 --- a/pdata/pmetric/generated_summarydatapointvalueatquantileslice.go +++ b/pdata/pmetric/generated_summarydatapointvalueatquantileslice.go @@ -29,6 +29,14 @@ func newSummaryDataPointValueAtQuantileSlice(orig *[]*otlpmetrics.SummaryDataPoi return SummaryDataPointValueAtQuantileSlice{orig: orig, state: state} } +func (ms SummaryDataPointValueAtQuantileSlice) getOrig() *[]*otlpmetrics.SummaryDataPoint_ValueAtQuantile { + return ms.orig +} + +func (ms SummaryDataPointValueAtQuantileSlice) getState() *internal.State { + return ms.state +} + // NewSummaryDataPointValueAtQuantileSlice creates a SummaryDataPointValueAtQuantileSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewSummaryDataPointValueAtQuantileSlice() SummaryDataPointValueAtQuantileSlice { @@ -41,7 +49,7 @@ func NewSummaryDataPointValueAtQuantileSlice() SummaryDataPointValueAtQuantileSl // // Returns "0" for a newly instance created with "NewSummaryDataPointValueAtQuantileSlice()". func (es SummaryDataPointValueAtQuantileSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es SummaryDataPointValueAtQuantileSlice) Len() int { // ... // Do something with the element // } func (es SummaryDataPointValueAtQuantileSlice) At(i int) SummaryDataPointValueAtQuantile { - return newSummaryDataPointValueAtQuantile((*es.orig)[i], es.state) + return newSummaryDataPointValueAtQuantile((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es SummaryDataPointValueAtQuantileSlice) At(i int) SummaryDataPointValueAt // // Here should set all the values for e. // } func (es SummaryDataPointValueAtQuantileSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpmetrics.SummaryDataPoint_ValueAtQuantile, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpmetrics.SummaryDataPoint_ValueAtQuantile, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty SummaryDataPointValueAtQuantile. // It returns the newly added SummaryDataPointValueAtQuantile. func (es SummaryDataPointValueAtQuantileSlice) AppendEmpty() SummaryDataPointValueAtQuantile { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es SummaryDataPointValueAtQuantileSlice) MoveAndAppendTo(dest SummaryDataPointValueAtQuantileSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es SummaryDataPointValueAtQuantileSlice) RemoveIf(f func(SummaryDataPointValueAtQuantile) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es SummaryDataPointValueAtQuantileSlice) RemoveIf(f func(SummaryDataPointV newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es SummaryDataPointValueAtQuantileSlice) CopyTo(dest SummaryDataPointValueAtQuantileSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newSummaryDataPointValueAtQuantile((*es.orig)[i], es.state).CopyTo(newSummaryDataPointValueAtQuantile((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newSummaryDataPointValueAtQuantile((*es.getOrig())[i], es.getState()).CopyTo(newSummaryDataPointValueAtQuantile((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpmetrics.SummaryDataPoint_ValueAtQuantile, srcLen) wrappers := make([]*otlpmetrics.SummaryDataPoint_ValueAtQuantile, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newSummaryDataPointValueAtQuantile((*es.orig)[i], es.state).CopyTo(newSummaryDataPointValueAtQuantile(wrappers[i], dest.state)) + newSummaryDataPointValueAtQuantile((*es.getOrig())[i], es.getState()).CopyTo(newSummaryDataPointValueAtQuantile(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the SummaryDataPointValueAtQuantile elements within SummaryDataPointValueAtQuantileSlice given the // provided less function so that two instances of SummaryDataPointValueAtQuantileSlice // can be compared. func (es SummaryDataPointValueAtQuantileSlice) Sort(less func(a, b SummaryDataPointValueAtQuantile) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go b/pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go index f879c4bc478..17c72216b86 100644 --- a/pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go +++ b/pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go @@ -69,14 +69,14 @@ func TestSummaryDataPointValueAtQuantileSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestSummaryDataPointValueAtQuantileSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestSummaryDataPointValueAtQuantileSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestSummaryDataPointValueAtQuantileSlice(), es) } @@ -126,16 +126,16 @@ func TestSummaryDataPointValueAtQuantileSlice_RemoveIf(t *testing.T) { func TestSummaryDataPointValueAtQuantileSlice_Sort(t *testing.T) { es := generateTestSummaryDataPointValueAtQuantileSlice() es.Sort(func(a, b SummaryDataPointValueAtQuantile) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b SummaryDataPointValueAtQuantile) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pmetric/pmetricotlp/generated_exportpartialsuccess.go b/pdata/pmetric/pmetricotlp/generated_exportpartialsuccess.go index 60aa6a03e95..9b721396562 100644 --- a/pdata/pmetric/pmetricotlp/generated_exportpartialsuccess.go +++ b/pdata/pmetric/pmetricotlp/generated_exportpartialsuccess.go @@ -45,6 +45,14 @@ func (ms ExportPartialSuccess) MoveTo(dest ExportPartialSuccess) { *ms.orig = otlpcollectormetrics.ExportMetricsPartialSuccess{} } +func (ms ExportPartialSuccess) getOrig() *otlpcollectormetrics.ExportMetricsPartialSuccess { + return ms.orig +} + +func (ms ExportPartialSuccess) getState() *internal.State { + return ms.state +} + // RejectedDataPoints returns the rejecteddatapoints associated with this ExportPartialSuccess. func (ms ExportPartialSuccess) RejectedDataPoints() int64 { return ms.orig.RejectedDataPoints diff --git a/pdata/pprofile/generated_attributeunit.go b/pdata/pprofile/generated_attributeunit.go index bb6f5e4d0dd..0568d01f0cd 100644 --- a/pdata/pprofile/generated_attributeunit.go +++ b/pdata/pprofile/generated_attributeunit.go @@ -45,6 +45,14 @@ func (ms AttributeUnit) MoveTo(dest AttributeUnit) { *ms.orig = otlpprofiles.AttributeUnit{} } +func (ms AttributeUnit) getOrig() *otlpprofiles.AttributeUnit { + return ms.orig +} + +func (ms AttributeUnit) getState() *internal.State { + return ms.state +} + // AttributeKey returns the attributekey associated with this AttributeUnit. func (ms AttributeUnit) AttributeKey() int64 { return ms.orig.AttributeKey diff --git a/pdata/pprofile/generated_attributeunitslice.go b/pdata/pprofile/generated_attributeunitslice.go index 95274cfe446..bb1569285ec 100644 --- a/pdata/pprofile/generated_attributeunitslice.go +++ b/pdata/pprofile/generated_attributeunitslice.go @@ -27,6 +27,14 @@ func newAttributeUnitSlice(orig *[]otlpprofiles.AttributeUnit, state *internal.S return AttributeUnitSlice{orig: orig, state: state} } +func (ms AttributeUnitSlice) getOrig() *[]otlpprofiles.AttributeUnit { + return ms.orig +} + +func (ms AttributeUnitSlice) getState() *internal.State { + return ms.state +} + // NewAttributeUnitSlice creates a AttributeUnitSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewAttributeUnitSlice() AttributeUnitSlice { @@ -39,7 +47,7 @@ func NewAttributeUnitSlice() AttributeUnitSlice { // // Returns "0" for a newly instance created with "NewAttributeUnitSlice()". func (es AttributeUnitSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es AttributeUnitSlice) Len() int { // ... // Do something with the element // } func (es AttributeUnitSlice) At(i int) AttributeUnit { - return newAttributeUnit(&(*es.orig)[i], es.state) + return newAttributeUnit(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es AttributeUnitSlice) At(i int) AttributeUnit { // // Here should set all the values for e. // } func (es AttributeUnitSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpprofiles.AttributeUnit, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpprofiles.AttributeUnit, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty AttributeUnit. // It returns the newly added AttributeUnit. func (es AttributeUnitSlice) AppendEmpty() AttributeUnit { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpprofiles.AttributeUnit{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpprofiles.AttributeUnit{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es AttributeUnitSlice) MoveAndAppendTo(dest AttributeUnitSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es AttributeUnitSlice) RemoveIf(f func(AttributeUnit) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es AttributeUnitSlice) RemoveIf(f func(AttributeUnit) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es AttributeUnitSlice) CopyTo(dest AttributeUnitSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpprofiles.AttributeUnit, srcLen) + (*dest.getOrig()) = make([]otlpprofiles.AttributeUnit, srcLen) } - for i := range *es.orig { - newAttributeUnit(&(*es.orig)[i], es.state).CopyTo(newAttributeUnit(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newAttributeUnit(&(*es.getOrig())[i], es.getState()).CopyTo(newAttributeUnit(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pprofile/generated_attributeunitslice_test.go b/pdata/pprofile/generated_attributeunitslice_test.go index 0dd3420015a..15b6e7ee761 100644 --- a/pdata/pprofile/generated_attributeunitslice_test.go +++ b/pdata/pprofile/generated_attributeunitslice_test.go @@ -68,14 +68,14 @@ func TestAttributeUnitSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestAttributeUnitSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestAttributeUnitSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestAttributeUnitSlice(), es) } diff --git a/pdata/pprofile/generated_function.go b/pdata/pprofile/generated_function.go index 324b8c7b109..c052bfa5257 100644 --- a/pdata/pprofile/generated_function.go +++ b/pdata/pprofile/generated_function.go @@ -45,6 +45,14 @@ func (ms Function) MoveTo(dest Function) { *ms.orig = otlpprofiles.Function{} } +func (ms Function) getOrig() *otlpprofiles.Function { + return ms.orig +} + +func (ms Function) getState() *internal.State { + return ms.state +} + // ID returns the id associated with this Function. func (ms Function) ID() uint64 { return ms.orig.Id diff --git a/pdata/pprofile/generated_functionslice.go b/pdata/pprofile/generated_functionslice.go index 171ba345b01..1c844627037 100644 --- a/pdata/pprofile/generated_functionslice.go +++ b/pdata/pprofile/generated_functionslice.go @@ -27,6 +27,14 @@ func newFunctionSlice(orig *[]otlpprofiles.Function, state *internal.State) Func return FunctionSlice{orig: orig, state: state} } +func (ms FunctionSlice) getOrig() *[]otlpprofiles.Function { + return ms.orig +} + +func (ms FunctionSlice) getState() *internal.State { + return ms.state +} + // NewFunctionSlice creates a FunctionSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewFunctionSlice() FunctionSlice { @@ -39,7 +47,7 @@ func NewFunctionSlice() FunctionSlice { // // Returns "0" for a newly instance created with "NewFunctionSlice()". func (es FunctionSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es FunctionSlice) Len() int { // ... // Do something with the element // } func (es FunctionSlice) At(i int) Function { - return newFunction(&(*es.orig)[i], es.state) + return newFunction(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es FunctionSlice) At(i int) Function { // // Here should set all the values for e. // } func (es FunctionSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpprofiles.Function, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpprofiles.Function, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Function. // It returns the newly added Function. func (es FunctionSlice) AppendEmpty() Function { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpprofiles.Function{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpprofiles.Function{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es FunctionSlice) MoveAndAppendTo(dest FunctionSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es FunctionSlice) RemoveIf(f func(Function) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es FunctionSlice) RemoveIf(f func(Function) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es FunctionSlice) CopyTo(dest FunctionSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpprofiles.Function, srcLen) + (*dest.getOrig()) = make([]otlpprofiles.Function, srcLen) } - for i := range *es.orig { - newFunction(&(*es.orig)[i], es.state).CopyTo(newFunction(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newFunction(&(*es.getOrig())[i], es.getState()).CopyTo(newFunction(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pprofile/generated_functionslice_test.go b/pdata/pprofile/generated_functionslice_test.go index c4311bf52d9..534ea571ed9 100644 --- a/pdata/pprofile/generated_functionslice_test.go +++ b/pdata/pprofile/generated_functionslice_test.go @@ -68,14 +68,14 @@ func TestFunctionSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestFunctionSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestFunctionSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestFunctionSlice(), es) } diff --git a/pdata/pprofile/generated_label.go b/pdata/pprofile/generated_label.go index fc93d13b390..5fc96ff1986 100644 --- a/pdata/pprofile/generated_label.go +++ b/pdata/pprofile/generated_label.go @@ -45,6 +45,14 @@ func (ms Label) MoveTo(dest Label) { *ms.orig = otlpprofiles.Label{} } +func (ms Label) getOrig() *otlpprofiles.Label { + return ms.orig +} + +func (ms Label) getState() *internal.State { + return ms.state +} + // Key returns the key associated with this Label. func (ms Label) Key() int64 { return ms.orig.Key diff --git a/pdata/pprofile/generated_labelslice.go b/pdata/pprofile/generated_labelslice.go index 5f865bfcbae..f5e4af6bc65 100644 --- a/pdata/pprofile/generated_labelslice.go +++ b/pdata/pprofile/generated_labelslice.go @@ -27,6 +27,14 @@ func newLabelSlice(orig *[]otlpprofiles.Label, state *internal.State) LabelSlice return LabelSlice{orig: orig, state: state} } +func (ms LabelSlice) getOrig() *[]otlpprofiles.Label { + return ms.orig +} + +func (ms LabelSlice) getState() *internal.State { + return ms.state +} + // NewLabelSlice creates a LabelSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewLabelSlice() LabelSlice { @@ -39,7 +47,7 @@ func NewLabelSlice() LabelSlice { // // Returns "0" for a newly instance created with "NewLabelSlice()". func (es LabelSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es LabelSlice) Len() int { // ... // Do something with the element // } func (es LabelSlice) At(i int) Label { - return newLabel(&(*es.orig)[i], es.state) + return newLabel(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es LabelSlice) At(i int) Label { // // Here should set all the values for e. // } func (es LabelSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpprofiles.Label, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpprofiles.Label, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Label. // It returns the newly added Label. func (es LabelSlice) AppendEmpty() Label { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpprofiles.Label{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpprofiles.Label{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es LabelSlice) MoveAndAppendTo(dest LabelSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es LabelSlice) RemoveIf(f func(Label) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es LabelSlice) RemoveIf(f func(Label) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es LabelSlice) CopyTo(dest LabelSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpprofiles.Label, srcLen) + (*dest.getOrig()) = make([]otlpprofiles.Label, srcLen) } - for i := range *es.orig { - newLabel(&(*es.orig)[i], es.state).CopyTo(newLabel(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newLabel(&(*es.getOrig())[i], es.getState()).CopyTo(newLabel(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pprofile/generated_labelslice_test.go b/pdata/pprofile/generated_labelslice_test.go index c399046f92e..2a6d2e5841c 100644 --- a/pdata/pprofile/generated_labelslice_test.go +++ b/pdata/pprofile/generated_labelslice_test.go @@ -68,14 +68,14 @@ func TestLabelSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestLabelSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestLabelSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestLabelSlice(), es) } diff --git a/pdata/pprofile/generated_line.go b/pdata/pprofile/generated_line.go index 80147d393a5..5389dfee966 100644 --- a/pdata/pprofile/generated_line.go +++ b/pdata/pprofile/generated_line.go @@ -45,6 +45,14 @@ func (ms Line) MoveTo(dest Line) { *ms.orig = otlpprofiles.Line{} } +func (ms Line) getOrig() *otlpprofiles.Line { + return ms.orig +} + +func (ms Line) getState() *internal.State { + return ms.state +} + // FunctionIndex returns the functionindex associated with this Line. func (ms Line) FunctionIndex() uint64 { return ms.orig.FunctionIndex diff --git a/pdata/pprofile/generated_lineslice.go b/pdata/pprofile/generated_lineslice.go index b354560d090..6014ac78b19 100644 --- a/pdata/pprofile/generated_lineslice.go +++ b/pdata/pprofile/generated_lineslice.go @@ -27,6 +27,14 @@ func newLineSlice(orig *[]otlpprofiles.Line, state *internal.State) LineSlice { return LineSlice{orig: orig, state: state} } +func (ms LineSlice) getOrig() *[]otlpprofiles.Line { + return ms.orig +} + +func (ms LineSlice) getState() *internal.State { + return ms.state +} + // NewLineSlice creates a LineSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewLineSlice() LineSlice { @@ -39,7 +47,7 @@ func NewLineSlice() LineSlice { // // Returns "0" for a newly instance created with "NewLineSlice()". func (es LineSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es LineSlice) Len() int { // ... // Do something with the element // } func (es LineSlice) At(i int) Line { - return newLine(&(*es.orig)[i], es.state) + return newLine(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es LineSlice) At(i int) Line { // // Here should set all the values for e. // } func (es LineSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpprofiles.Line, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpprofiles.Line, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Line. // It returns the newly added Line. func (es LineSlice) AppendEmpty() Line { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpprofiles.Line{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpprofiles.Line{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es LineSlice) MoveAndAppendTo(dest LineSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es LineSlice) RemoveIf(f func(Line) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es LineSlice) RemoveIf(f func(Line) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es LineSlice) CopyTo(dest LineSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpprofiles.Line, srcLen) + (*dest.getOrig()) = make([]otlpprofiles.Line, srcLen) } - for i := range *es.orig { - newLine(&(*es.orig)[i], es.state).CopyTo(newLine(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newLine(&(*es.getOrig())[i], es.getState()).CopyTo(newLine(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pprofile/generated_lineslice_test.go b/pdata/pprofile/generated_lineslice_test.go index 1f5a69ca3f4..91dcf14262b 100644 --- a/pdata/pprofile/generated_lineslice_test.go +++ b/pdata/pprofile/generated_lineslice_test.go @@ -68,14 +68,14 @@ func TestLineSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestLineSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestLineSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestLineSlice(), es) } diff --git a/pdata/pprofile/generated_link.go b/pdata/pprofile/generated_link.go index 70af00112b0..897fc37b3b6 100644 --- a/pdata/pprofile/generated_link.go +++ b/pdata/pprofile/generated_link.go @@ -47,6 +47,14 @@ func (ms Link) MoveTo(dest Link) { *ms.orig = otlpprofiles.Link{} } +func (ms Link) getOrig() *otlpprofiles.Link { + return ms.orig +} + +func (ms Link) getState() *internal.State { + return ms.state +} + // TraceID returns the traceid associated with this Link. func (ms Link) TraceID() pcommon.TraceID { return pcommon.TraceID(ms.orig.TraceId) diff --git a/pdata/pprofile/generated_linkslice.go b/pdata/pprofile/generated_linkslice.go index 3ae925ac09c..66137b13a5c 100644 --- a/pdata/pprofile/generated_linkslice.go +++ b/pdata/pprofile/generated_linkslice.go @@ -27,6 +27,14 @@ func newLinkSlice(orig *[]otlpprofiles.Link, state *internal.State) LinkSlice { return LinkSlice{orig: orig, state: state} } +func (ms LinkSlice) getOrig() *[]otlpprofiles.Link { + return ms.orig +} + +func (ms LinkSlice) getState() *internal.State { + return ms.state +} + // NewLinkSlice creates a LinkSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewLinkSlice() LinkSlice { @@ -39,7 +47,7 @@ func NewLinkSlice() LinkSlice { // // Returns "0" for a newly instance created with "NewLinkSlice()". func (es LinkSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es LinkSlice) Len() int { // ... // Do something with the element // } func (es LinkSlice) At(i int) Link { - return newLink(&(*es.orig)[i], es.state) + return newLink(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es LinkSlice) At(i int) Link { // // Here should set all the values for e. // } func (es LinkSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpprofiles.Link, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpprofiles.Link, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Link. // It returns the newly added Link. func (es LinkSlice) AppendEmpty() Link { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpprofiles.Link{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpprofiles.Link{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es LinkSlice) MoveAndAppendTo(dest LinkSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es LinkSlice) RemoveIf(f func(Link) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es LinkSlice) RemoveIf(f func(Link) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es LinkSlice) CopyTo(dest LinkSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpprofiles.Link, srcLen) + (*dest.getOrig()) = make([]otlpprofiles.Link, srcLen) } - for i := range *es.orig { - newLink(&(*es.orig)[i], es.state).CopyTo(newLink(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newLink(&(*es.getOrig())[i], es.getState()).CopyTo(newLink(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pprofile/generated_linkslice_test.go b/pdata/pprofile/generated_linkslice_test.go index 5d22fcd69ca..9defdd31a92 100644 --- a/pdata/pprofile/generated_linkslice_test.go +++ b/pdata/pprofile/generated_linkslice_test.go @@ -68,14 +68,14 @@ func TestLinkSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestLinkSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestLinkSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestLinkSlice(), es) } diff --git a/pdata/pprofile/generated_location.go b/pdata/pprofile/generated_location.go index 5ed030f6d6d..025c759156f 100644 --- a/pdata/pprofile/generated_location.go +++ b/pdata/pprofile/generated_location.go @@ -46,6 +46,14 @@ func (ms Location) MoveTo(dest Location) { *ms.orig = otlpprofiles.Location{} } +func (ms Location) getOrig() *otlpprofiles.Location { + return ms.orig +} + +func (ms Location) getState() *internal.State { + return ms.state +} + // ID returns the id associated with this Location. func (ms Location) ID() uint64 { return ms.orig.Id diff --git a/pdata/pprofile/generated_locationslice.go b/pdata/pprofile/generated_locationslice.go index e5751c4dcb6..a65a357153f 100644 --- a/pdata/pprofile/generated_locationslice.go +++ b/pdata/pprofile/generated_locationslice.go @@ -27,6 +27,14 @@ func newLocationSlice(orig *[]otlpprofiles.Location, state *internal.State) Loca return LocationSlice{orig: orig, state: state} } +func (ms LocationSlice) getOrig() *[]otlpprofiles.Location { + return ms.orig +} + +func (ms LocationSlice) getState() *internal.State { + return ms.state +} + // NewLocationSlice creates a LocationSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewLocationSlice() LocationSlice { @@ -39,7 +47,7 @@ func NewLocationSlice() LocationSlice { // // Returns "0" for a newly instance created with "NewLocationSlice()". func (es LocationSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es LocationSlice) Len() int { // ... // Do something with the element // } func (es LocationSlice) At(i int) Location { - return newLocation(&(*es.orig)[i], es.state) + return newLocation(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es LocationSlice) At(i int) Location { // // Here should set all the values for e. // } func (es LocationSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpprofiles.Location, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpprofiles.Location, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Location. // It returns the newly added Location. func (es LocationSlice) AppendEmpty() Location { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpprofiles.Location{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpprofiles.Location{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es LocationSlice) MoveAndAppendTo(dest LocationSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es LocationSlice) RemoveIf(f func(Location) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es LocationSlice) RemoveIf(f func(Location) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es LocationSlice) CopyTo(dest LocationSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpprofiles.Location, srcLen) + (*dest.getOrig()) = make([]otlpprofiles.Location, srcLen) } - for i := range *es.orig { - newLocation(&(*es.orig)[i], es.state).CopyTo(newLocation(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newLocation(&(*es.getOrig())[i], es.getState()).CopyTo(newLocation(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pprofile/generated_locationslice_test.go b/pdata/pprofile/generated_locationslice_test.go index 06d6946279f..d174bcfc606 100644 --- a/pdata/pprofile/generated_locationslice_test.go +++ b/pdata/pprofile/generated_locationslice_test.go @@ -68,14 +68,14 @@ func TestLocationSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestLocationSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestLocationSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestLocationSlice(), es) } diff --git a/pdata/pprofile/generated_mapping.go b/pdata/pprofile/generated_mapping.go index 66c7cd165df..5533f9de6c8 100644 --- a/pdata/pprofile/generated_mapping.go +++ b/pdata/pprofile/generated_mapping.go @@ -46,6 +46,14 @@ func (ms Mapping) MoveTo(dest Mapping) { *ms.orig = otlpprofiles.Mapping{} } +func (ms Mapping) getOrig() *otlpprofiles.Mapping { + return ms.orig +} + +func (ms Mapping) getState() *internal.State { + return ms.state +} + // ID returns the id associated with this Mapping. func (ms Mapping) ID() uint64 { return ms.orig.Id diff --git a/pdata/pprofile/generated_mappingslice.go b/pdata/pprofile/generated_mappingslice.go index cf0f1361483..85a768b530e 100644 --- a/pdata/pprofile/generated_mappingslice.go +++ b/pdata/pprofile/generated_mappingslice.go @@ -27,6 +27,14 @@ func newMappingSlice(orig *[]otlpprofiles.Mapping, state *internal.State) Mappin return MappingSlice{orig: orig, state: state} } +func (ms MappingSlice) getOrig() *[]otlpprofiles.Mapping { + return ms.orig +} + +func (ms MappingSlice) getState() *internal.State { + return ms.state +} + // NewMappingSlice creates a MappingSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewMappingSlice() MappingSlice { @@ -39,7 +47,7 @@ func NewMappingSlice() MappingSlice { // // Returns "0" for a newly instance created with "NewMappingSlice()". func (es MappingSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es MappingSlice) Len() int { // ... // Do something with the element // } func (es MappingSlice) At(i int) Mapping { - return newMapping(&(*es.orig)[i], es.state) + return newMapping(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es MappingSlice) At(i int) Mapping { // // Here should set all the values for e. // } func (es MappingSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpprofiles.Mapping, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpprofiles.Mapping, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Mapping. // It returns the newly added Mapping. func (es MappingSlice) AppendEmpty() Mapping { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpprofiles.Mapping{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpprofiles.Mapping{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es MappingSlice) MoveAndAppendTo(dest MappingSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es MappingSlice) RemoveIf(f func(Mapping) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es MappingSlice) RemoveIf(f func(Mapping) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es MappingSlice) CopyTo(dest MappingSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpprofiles.Mapping, srcLen) + (*dest.getOrig()) = make([]otlpprofiles.Mapping, srcLen) } - for i := range *es.orig { - newMapping(&(*es.orig)[i], es.state).CopyTo(newMapping(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newMapping(&(*es.getOrig())[i], es.getState()).CopyTo(newMapping(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pprofile/generated_mappingslice_test.go b/pdata/pprofile/generated_mappingslice_test.go index b25cb952ce1..951792ea1ea 100644 --- a/pdata/pprofile/generated_mappingslice_test.go +++ b/pdata/pprofile/generated_mappingslice_test.go @@ -68,14 +68,14 @@ func TestMappingSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestMappingSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestMappingSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestMappingSlice(), es) } diff --git a/pdata/pprofile/generated_profile.go b/pdata/pprofile/generated_profile.go index 38f1cf3f0f3..a15d744bc89 100644 --- a/pdata/pprofile/generated_profile.go +++ b/pdata/pprofile/generated_profile.go @@ -46,6 +46,14 @@ func (ms Profile) MoveTo(dest Profile) { *ms.orig = otlpprofiles.Profile{} } +func (ms Profile) getOrig() *otlpprofiles.Profile { + return ms.orig +} + +func (ms Profile) getState() *internal.State { + return ms.state +} + // SampleType returns the SampleType associated with this Profile. func (ms Profile) SampleType() ValueTypeSlice { return newValueTypeSlice(&ms.orig.SampleType, ms.state) diff --git a/pdata/pprofile/generated_profilecontainer.go b/pdata/pprofile/generated_profilecontainer.go index 9f597728565..f2f9eb36bca 100644 --- a/pdata/pprofile/generated_profilecontainer.go +++ b/pdata/pprofile/generated_profilecontainer.go @@ -47,6 +47,14 @@ func (ms ProfileContainer) MoveTo(dest ProfileContainer) { *ms.orig = otlpprofiles.ProfileContainer{} } +func (ms ProfileContainer) getOrig() *otlpprofiles.ProfileContainer { + return ms.orig +} + +func (ms ProfileContainer) getState() *internal.State { + return ms.state +} + // ProfileID returns the profileid associated with this ProfileContainer. func (ms ProfileContainer) ProfileID() ProfileID { return ProfileID(ms.orig.ProfileId) diff --git a/pdata/pprofile/generated_profilescontainersslice.go b/pdata/pprofile/generated_profilescontainersslice.go index 74ac2cc4578..ac1979eefc2 100644 --- a/pdata/pprofile/generated_profilescontainersslice.go +++ b/pdata/pprofile/generated_profilescontainersslice.go @@ -29,6 +29,14 @@ func newProfilesContainersSlice(orig *[]*otlpprofiles.ProfileContainer, state *i return ProfilesContainersSlice{orig: orig, state: state} } +func (ms ProfilesContainersSlice) getOrig() *[]*otlpprofiles.ProfileContainer { + return ms.orig +} + +func (ms ProfilesContainersSlice) getState() *internal.State { + return ms.state +} + // NewProfilesContainersSlice creates a ProfilesContainersSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewProfilesContainersSlice() ProfilesContainersSlice { @@ -41,7 +49,7 @@ func NewProfilesContainersSlice() ProfilesContainersSlice { // // Returns "0" for a newly instance created with "NewProfilesContainersSlice()". func (es ProfilesContainersSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ProfilesContainersSlice) Len() int { // ... // Do something with the element // } func (es ProfilesContainersSlice) At(i int) ProfileContainer { - return newProfileContainer((*es.orig)[i], es.state) + return newProfileContainer((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ProfilesContainersSlice) At(i int) ProfileContainer { // // Here should set all the values for e. // } func (es ProfilesContainersSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpprofiles.ProfileContainer, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpprofiles.ProfileContainer, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ProfileContainer. // It returns the newly added ProfileContainer. func (es ProfilesContainersSlice) AppendEmpty() ProfileContainer { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpprofiles.ProfileContainer{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpprofiles.ProfileContainer{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ProfilesContainersSlice) MoveAndAppendTo(dest ProfilesContainersSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ProfilesContainersSlice) RemoveIf(f func(ProfileContainer) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ProfilesContainersSlice) RemoveIf(f func(ProfileContainer) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ProfilesContainersSlice) CopyTo(dest ProfilesContainersSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newProfileContainer((*es.orig)[i], es.state).CopyTo(newProfileContainer((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newProfileContainer((*es.getOrig())[i], es.getState()).CopyTo(newProfileContainer((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpprofiles.ProfileContainer, srcLen) wrappers := make([]*otlpprofiles.ProfileContainer, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newProfileContainer((*es.orig)[i], es.state).CopyTo(newProfileContainer(wrappers[i], dest.state)) + newProfileContainer((*es.getOrig())[i], es.getState()).CopyTo(newProfileContainer(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ProfileContainer elements within ProfilesContainersSlice given the // provided less function so that two instances of ProfilesContainersSlice // can be compared. func (es ProfilesContainersSlice) Sort(less func(a, b ProfileContainer) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pprofile/generated_profilescontainersslice_test.go b/pdata/pprofile/generated_profilescontainersslice_test.go index 902fd4cf24b..168cc77e6a7 100644 --- a/pdata/pprofile/generated_profilescontainersslice_test.go +++ b/pdata/pprofile/generated_profilescontainersslice_test.go @@ -69,14 +69,14 @@ func TestProfilesContainersSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestProfilesContainersSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestProfilesContainersSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestProfilesContainersSlice(), es) } @@ -126,16 +126,16 @@ func TestProfilesContainersSlice_RemoveIf(t *testing.T) { func TestProfilesContainersSlice_Sort(t *testing.T) { es := generateTestProfilesContainersSlice() es.Sort(func(a, b ProfileContainer) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ProfileContainer) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pprofile/generated_resourceprofiles.go b/pdata/pprofile/generated_resourceprofiles.go index 35c0161d7d7..13e72f33194 100644 --- a/pdata/pprofile/generated_resourceprofiles.go +++ b/pdata/pprofile/generated_resourceprofiles.go @@ -46,6 +46,14 @@ func (ms ResourceProfiles) MoveTo(dest ResourceProfiles) { *ms.orig = otlpprofiles.ResourceProfiles{} } +func (ms ResourceProfiles) getOrig() *otlpprofiles.ResourceProfiles { + return ms.orig +} + +func (ms ResourceProfiles) getState() *internal.State { + return ms.state +} + // Resource returns the resource associated with this ResourceProfiles. func (ms ResourceProfiles) Resource() pcommon.Resource { return pcommon.Resource(internal.NewResource(&ms.orig.Resource, ms.state)) diff --git a/pdata/pprofile/generated_resourceprofilesslice.go b/pdata/pprofile/generated_resourceprofilesslice.go index b8ea2a71ba1..6affa53388e 100644 --- a/pdata/pprofile/generated_resourceprofilesslice.go +++ b/pdata/pprofile/generated_resourceprofilesslice.go @@ -29,6 +29,14 @@ func newResourceProfilesSlice(orig *[]*otlpprofiles.ResourceProfiles, state *int return ResourceProfilesSlice{orig: orig, state: state} } +func (ms ResourceProfilesSlice) getOrig() *[]*otlpprofiles.ResourceProfiles { + return ms.orig +} + +func (ms ResourceProfilesSlice) getState() *internal.State { + return ms.state +} + // NewResourceProfilesSlice creates a ResourceProfilesSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewResourceProfilesSlice() ResourceProfilesSlice { @@ -41,7 +49,7 @@ func NewResourceProfilesSlice() ResourceProfilesSlice { // // Returns "0" for a newly instance created with "NewResourceProfilesSlice()". func (es ResourceProfilesSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ResourceProfilesSlice) Len() int { // ... // Do something with the element // } func (es ResourceProfilesSlice) At(i int) ResourceProfiles { - return newResourceProfiles((*es.orig)[i], es.state) + return newResourceProfiles((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ResourceProfilesSlice) At(i int) ResourceProfiles { // // Here should set all the values for e. // } func (es ResourceProfilesSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpprofiles.ResourceProfiles, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpprofiles.ResourceProfiles, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ResourceProfiles. // It returns the newly added ResourceProfiles. func (es ResourceProfilesSlice) AppendEmpty() ResourceProfiles { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpprofiles.ResourceProfiles{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpprofiles.ResourceProfiles{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ResourceProfilesSlice) MoveAndAppendTo(dest ResourceProfilesSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ResourceProfilesSlice) RemoveIf(f func(ResourceProfiles) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ResourceProfilesSlice) RemoveIf(f func(ResourceProfiles) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ResourceProfilesSlice) CopyTo(dest ResourceProfilesSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newResourceProfiles((*es.orig)[i], es.state).CopyTo(newResourceProfiles((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newResourceProfiles((*es.getOrig())[i], es.getState()).CopyTo(newResourceProfiles((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpprofiles.ResourceProfiles, srcLen) wrappers := make([]*otlpprofiles.ResourceProfiles, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newResourceProfiles((*es.orig)[i], es.state).CopyTo(newResourceProfiles(wrappers[i], dest.state)) + newResourceProfiles((*es.getOrig())[i], es.getState()).CopyTo(newResourceProfiles(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ResourceProfiles elements within ResourceProfilesSlice given the // provided less function so that two instances of ResourceProfilesSlice // can be compared. func (es ResourceProfilesSlice) Sort(less func(a, b ResourceProfiles) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pprofile/generated_resourceprofilesslice_test.go b/pdata/pprofile/generated_resourceprofilesslice_test.go index 32ec740a939..41520911188 100644 --- a/pdata/pprofile/generated_resourceprofilesslice_test.go +++ b/pdata/pprofile/generated_resourceprofilesslice_test.go @@ -69,14 +69,14 @@ func TestResourceProfilesSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestResourceProfilesSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestResourceProfilesSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestResourceProfilesSlice(), es) } @@ -126,16 +126,16 @@ func TestResourceProfilesSlice_RemoveIf(t *testing.T) { func TestResourceProfilesSlice_Sort(t *testing.T) { es := generateTestResourceProfilesSlice() es.Sort(func(a, b ResourceProfiles) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ResourceProfiles) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pprofile/generated_sample.go b/pdata/pprofile/generated_sample.go index 3627b60f7e2..02037dbf0b1 100644 --- a/pdata/pprofile/generated_sample.go +++ b/pdata/pprofile/generated_sample.go @@ -46,6 +46,14 @@ func (ms Sample) MoveTo(dest Sample) { *ms.orig = otlpprofiles.Sample{} } +func (ms Sample) getOrig() *otlpprofiles.Sample { + return ms.orig +} + +func (ms Sample) getState() *internal.State { + return ms.state +} + // LocationIndex returns the LocationIndex associated with this Sample. func (ms Sample) LocationIndex() pcommon.UInt64Slice { return pcommon.UInt64Slice(internal.NewUInt64Slice(&ms.orig.LocationIndex, ms.state)) diff --git a/pdata/pprofile/generated_sampleslice.go b/pdata/pprofile/generated_sampleslice.go index da2a128cd6f..a4d51551073 100644 --- a/pdata/pprofile/generated_sampleslice.go +++ b/pdata/pprofile/generated_sampleslice.go @@ -27,6 +27,14 @@ func newSampleSlice(orig *[]otlpprofiles.Sample, state *internal.State) SampleSl return SampleSlice{orig: orig, state: state} } +func (ms SampleSlice) getOrig() *[]otlpprofiles.Sample { + return ms.orig +} + +func (ms SampleSlice) getState() *internal.State { + return ms.state +} + // NewSampleSlice creates a SampleSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewSampleSlice() SampleSlice { @@ -39,7 +47,7 @@ func NewSampleSlice() SampleSlice { // // Returns "0" for a newly instance created with "NewSampleSlice()". func (es SampleSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es SampleSlice) Len() int { // ... // Do something with the element // } func (es SampleSlice) At(i int) Sample { - return newSample(&(*es.orig)[i], es.state) + return newSample(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es SampleSlice) At(i int) Sample { // // Here should set all the values for e. // } func (es SampleSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpprofiles.Sample, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpprofiles.Sample, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Sample. // It returns the newly added Sample. func (es SampleSlice) AppendEmpty() Sample { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpprofiles.Sample{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpprofiles.Sample{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es SampleSlice) MoveAndAppendTo(dest SampleSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es SampleSlice) RemoveIf(f func(Sample) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es SampleSlice) RemoveIf(f func(Sample) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es SampleSlice) CopyTo(dest SampleSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpprofiles.Sample, srcLen) + (*dest.getOrig()) = make([]otlpprofiles.Sample, srcLen) } - for i := range *es.orig { - newSample(&(*es.orig)[i], es.state).CopyTo(newSample(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newSample(&(*es.getOrig())[i], es.getState()).CopyTo(newSample(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pprofile/generated_sampleslice_test.go b/pdata/pprofile/generated_sampleslice_test.go index 7533e51cc45..180cf9d60ae 100644 --- a/pdata/pprofile/generated_sampleslice_test.go +++ b/pdata/pprofile/generated_sampleslice_test.go @@ -68,14 +68,14 @@ func TestSampleSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestSampleSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestSampleSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestSampleSlice(), es) } diff --git a/pdata/pprofile/generated_scopeprofiles.go b/pdata/pprofile/generated_scopeprofiles.go index e213b2660ba..dd66aba9f0a 100644 --- a/pdata/pprofile/generated_scopeprofiles.go +++ b/pdata/pprofile/generated_scopeprofiles.go @@ -46,6 +46,14 @@ func (ms ScopeProfiles) MoveTo(dest ScopeProfiles) { *ms.orig = otlpprofiles.ScopeProfiles{} } +func (ms ScopeProfiles) getOrig() *otlpprofiles.ScopeProfiles { + return ms.orig +} + +func (ms ScopeProfiles) getState() *internal.State { + return ms.state +} + // Scope returns the scope associated with this ScopeProfiles. func (ms ScopeProfiles) Scope() pcommon.InstrumentationScope { return pcommon.InstrumentationScope(internal.NewInstrumentationScope(&ms.orig.Scope, ms.state)) diff --git a/pdata/pprofile/generated_scopeprofilesslice.go b/pdata/pprofile/generated_scopeprofilesslice.go index 766ee38310b..ba07d55806a 100644 --- a/pdata/pprofile/generated_scopeprofilesslice.go +++ b/pdata/pprofile/generated_scopeprofilesslice.go @@ -29,6 +29,14 @@ func newScopeProfilesSlice(orig *[]*otlpprofiles.ScopeProfiles, state *internal. return ScopeProfilesSlice{orig: orig, state: state} } +func (ms ScopeProfilesSlice) getOrig() *[]*otlpprofiles.ScopeProfiles { + return ms.orig +} + +func (ms ScopeProfilesSlice) getState() *internal.State { + return ms.state +} + // NewScopeProfilesSlice creates a ScopeProfilesSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewScopeProfilesSlice() ScopeProfilesSlice { @@ -41,7 +49,7 @@ func NewScopeProfilesSlice() ScopeProfilesSlice { // // Returns "0" for a newly instance created with "NewScopeProfilesSlice()". func (es ScopeProfilesSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ScopeProfilesSlice) Len() int { // ... // Do something with the element // } func (es ScopeProfilesSlice) At(i int) ScopeProfiles { - return newScopeProfiles((*es.orig)[i], es.state) + return newScopeProfiles((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ScopeProfilesSlice) At(i int) ScopeProfiles { // // Here should set all the values for e. // } func (es ScopeProfilesSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlpprofiles.ScopeProfiles, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlpprofiles.ScopeProfiles, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ScopeProfiles. // It returns the newly added ScopeProfiles. func (es ScopeProfilesSlice) AppendEmpty() ScopeProfiles { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlpprofiles.ScopeProfiles{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlpprofiles.ScopeProfiles{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ScopeProfilesSlice) MoveAndAppendTo(dest ScopeProfilesSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ScopeProfilesSlice) RemoveIf(f func(ScopeProfiles) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ScopeProfilesSlice) RemoveIf(f func(ScopeProfiles) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ScopeProfilesSlice) CopyTo(dest ScopeProfilesSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newScopeProfiles((*es.orig)[i], es.state).CopyTo(newScopeProfiles((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newScopeProfiles((*es.getOrig())[i], es.getState()).CopyTo(newScopeProfiles((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlpprofiles.ScopeProfiles, srcLen) wrappers := make([]*otlpprofiles.ScopeProfiles, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newScopeProfiles((*es.orig)[i], es.state).CopyTo(newScopeProfiles(wrappers[i], dest.state)) + newScopeProfiles((*es.getOrig())[i], es.getState()).CopyTo(newScopeProfiles(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ScopeProfiles elements within ScopeProfilesSlice given the // provided less function so that two instances of ScopeProfilesSlice // can be compared. func (es ScopeProfilesSlice) Sort(less func(a, b ScopeProfiles) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/pprofile/generated_scopeprofilesslice_test.go b/pdata/pprofile/generated_scopeprofilesslice_test.go index 78dc1f05f1a..d50ef6048aa 100644 --- a/pdata/pprofile/generated_scopeprofilesslice_test.go +++ b/pdata/pprofile/generated_scopeprofilesslice_test.go @@ -69,14 +69,14 @@ func TestScopeProfilesSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestScopeProfilesSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestScopeProfilesSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestScopeProfilesSlice(), es) } @@ -126,16 +126,16 @@ func TestScopeProfilesSlice_RemoveIf(t *testing.T) { func TestScopeProfilesSlice_Sort(t *testing.T) { es := generateTestScopeProfilesSlice() es.Sort(func(a, b ScopeProfiles) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ScopeProfiles) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/pprofile/generated_valuetype.go b/pdata/pprofile/generated_valuetype.go index 32280993a2d..59b5a8f189c 100644 --- a/pdata/pprofile/generated_valuetype.go +++ b/pdata/pprofile/generated_valuetype.go @@ -45,6 +45,14 @@ func (ms ValueType) MoveTo(dest ValueType) { *ms.orig = otlpprofiles.ValueType{} } +func (ms ValueType) getOrig() *otlpprofiles.ValueType { + return ms.orig +} + +func (ms ValueType) getState() *internal.State { + return ms.state +} + // Type returns the type associated with this ValueType. func (ms ValueType) Type() int64 { return ms.orig.Type diff --git a/pdata/pprofile/generated_valuetypeslice.go b/pdata/pprofile/generated_valuetypeslice.go index 4049bbd2e16..cd4a42d3312 100644 --- a/pdata/pprofile/generated_valuetypeslice.go +++ b/pdata/pprofile/generated_valuetypeslice.go @@ -27,6 +27,14 @@ func newValueTypeSlice(orig *[]otlpprofiles.ValueType, state *internal.State) Va return ValueTypeSlice{orig: orig, state: state} } +func (ms ValueTypeSlice) getOrig() *[]otlpprofiles.ValueType { + return ms.orig +} + +func (ms ValueTypeSlice) getState() *internal.State { + return ms.state +} + // NewValueTypeSlice creates a ValueTypeSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewValueTypeSlice() ValueTypeSlice { @@ -39,7 +47,7 @@ func NewValueTypeSlice() ValueTypeSlice { // // Returns "0" for a newly instance created with "NewValueTypeSlice()". func (es ValueTypeSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -51,7 +59,7 @@ func (es ValueTypeSlice) Len() int { // ... // Do something with the element // } func (es ValueTypeSlice) At(i int) ValueType { - return newValueType(&(*es.orig)[i], es.state) + return newValueType(&(*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -67,45 +75,45 @@ func (es ValueTypeSlice) At(i int) ValueType { // // Here should set all the values for e. // } func (es ValueTypeSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]otlpprofiles.ValueType, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]otlpprofiles.ValueType, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ValueType. // It returns the newly added ValueType. func (es ValueTypeSlice) AppendEmpty() ValueType { - es.state.AssertMutable() - *es.orig = append(*es.orig, otlpprofiles.ValueType{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), otlpprofiles.ValueType{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ValueTypeSlice) MoveAndAppendTo(dest ValueTypeSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ValueTypeSlice) RemoveIf(f func(ValueType) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -114,23 +122,23 @@ func (es ValueTypeSlice) RemoveIf(f func(ValueType) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ValueTypeSlice) CopyTo(dest ValueTypeSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] } else { - (*dest.orig) = make([]otlpprofiles.ValueType, srcLen) + (*dest.getOrig()) = make([]otlpprofiles.ValueType, srcLen) } - for i := range *es.orig { - newValueType(&(*es.orig)[i], es.state).CopyTo(newValueType(&(*dest.orig)[i], dest.state)) + for i := range *es.getOrig() { + newValueType(&(*es.getOrig())[i], es.getState()).CopyTo(newValueType(&(*dest.getOrig())[i], dest.getState())) } } diff --git a/pdata/pprofile/generated_valuetypeslice_test.go b/pdata/pprofile/generated_valuetypeslice_test.go index ac4ab1d7dab..bd59bbde724 100644 --- a/pdata/pprofile/generated_valuetypeslice_test.go +++ b/pdata/pprofile/generated_valuetypeslice_test.go @@ -68,14 +68,14 @@ func TestValueTypeSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestValueTypeSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestValueTypeSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestValueTypeSlice(), es) } diff --git a/pdata/pprofile/pprofileotlp/generated_exportpartialsuccess.go b/pdata/pprofile/pprofileotlp/generated_exportpartialsuccess.go index 2bc9e3dab81..585eeef1baf 100644 --- a/pdata/pprofile/pprofileotlp/generated_exportpartialsuccess.go +++ b/pdata/pprofile/pprofileotlp/generated_exportpartialsuccess.go @@ -45,6 +45,14 @@ func (ms ExportPartialSuccess) MoveTo(dest ExportPartialSuccess) { *ms.orig = otlpcollectorprofile.ExportProfilesPartialSuccess{} } +func (ms ExportPartialSuccess) getOrig() *otlpcollectorprofile.ExportProfilesPartialSuccess { + return ms.orig +} + +func (ms ExportPartialSuccess) getState() *internal.State { + return ms.state +} + // RejectedProfiles returns the rejectedprofiles associated with this ExportPartialSuccess. func (ms ExportPartialSuccess) RejectedProfiles() int64 { return ms.orig.RejectedProfiles diff --git a/pdata/ptrace/generated_resourcespans.go b/pdata/ptrace/generated_resourcespans.go index fc2ed01dbbc..cd69c886d16 100644 --- a/pdata/ptrace/generated_resourcespans.go +++ b/pdata/ptrace/generated_resourcespans.go @@ -46,6 +46,14 @@ func (ms ResourceSpans) MoveTo(dest ResourceSpans) { *ms.orig = otlptrace.ResourceSpans{} } +func (ms ResourceSpans) getOrig() *otlptrace.ResourceSpans { + return ms.orig +} + +func (ms ResourceSpans) getState() *internal.State { + return ms.state +} + // Resource returns the resource associated with this ResourceSpans. func (ms ResourceSpans) Resource() pcommon.Resource { return pcommon.Resource(internal.NewResource(&ms.orig.Resource, ms.state)) diff --git a/pdata/ptrace/generated_resourcespansslice.go b/pdata/ptrace/generated_resourcespansslice.go index da79ef4a342..79b5d3df584 100644 --- a/pdata/ptrace/generated_resourcespansslice.go +++ b/pdata/ptrace/generated_resourcespansslice.go @@ -29,6 +29,14 @@ func newResourceSpansSlice(orig *[]*otlptrace.ResourceSpans, state *internal.Sta return ResourceSpansSlice{orig: orig, state: state} } +func (ms ResourceSpansSlice) getOrig() *[]*otlptrace.ResourceSpans { + return ms.orig +} + +func (ms ResourceSpansSlice) getState() *internal.State { + return ms.state +} + // NewResourceSpansSlice creates a ResourceSpansSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewResourceSpansSlice() ResourceSpansSlice { @@ -41,7 +49,7 @@ func NewResourceSpansSlice() ResourceSpansSlice { // // Returns "0" for a newly instance created with "NewResourceSpansSlice()". func (es ResourceSpansSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ResourceSpansSlice) Len() int { // ... // Do something with the element // } func (es ResourceSpansSlice) At(i int) ResourceSpans { - return newResourceSpans((*es.orig)[i], es.state) + return newResourceSpans((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ResourceSpansSlice) At(i int) ResourceSpans { // // Here should set all the values for e. // } func (es ResourceSpansSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlptrace.ResourceSpans, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlptrace.ResourceSpans, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ResourceSpans. // It returns the newly added ResourceSpans. func (es ResourceSpansSlice) AppendEmpty() ResourceSpans { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlptrace.ResourceSpans{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlptrace.ResourceSpans{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ResourceSpansSlice) MoveAndAppendTo(dest ResourceSpansSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ResourceSpansSlice) RemoveIf(f func(ResourceSpans) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ResourceSpansSlice) RemoveIf(f func(ResourceSpans) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ResourceSpansSlice) CopyTo(dest ResourceSpansSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newResourceSpans((*es.orig)[i], es.state).CopyTo(newResourceSpans((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newResourceSpans((*es.getOrig())[i], es.getState()).CopyTo(newResourceSpans((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlptrace.ResourceSpans, srcLen) wrappers := make([]*otlptrace.ResourceSpans, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newResourceSpans((*es.orig)[i], es.state).CopyTo(newResourceSpans(wrappers[i], dest.state)) + newResourceSpans((*es.getOrig())[i], es.getState()).CopyTo(newResourceSpans(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ResourceSpans elements within ResourceSpansSlice given the // provided less function so that two instances of ResourceSpansSlice // can be compared. func (es ResourceSpansSlice) Sort(less func(a, b ResourceSpans) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/ptrace/generated_resourcespansslice_test.go b/pdata/ptrace/generated_resourcespansslice_test.go index 0a031d93420..d78184e78b4 100644 --- a/pdata/ptrace/generated_resourcespansslice_test.go +++ b/pdata/ptrace/generated_resourcespansslice_test.go @@ -69,14 +69,14 @@ func TestResourceSpansSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestResourceSpansSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestResourceSpansSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestResourceSpansSlice(), es) } @@ -126,16 +126,16 @@ func TestResourceSpansSlice_RemoveIf(t *testing.T) { func TestResourceSpansSlice_Sort(t *testing.T) { es := generateTestResourceSpansSlice() es.Sort(func(a, b ResourceSpans) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ResourceSpans) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/ptrace/generated_scopespans.go b/pdata/ptrace/generated_scopespans.go index 6ea0d82fd68..1463b8935d3 100644 --- a/pdata/ptrace/generated_scopespans.go +++ b/pdata/ptrace/generated_scopespans.go @@ -46,6 +46,14 @@ func (ms ScopeSpans) MoveTo(dest ScopeSpans) { *ms.orig = otlptrace.ScopeSpans{} } +func (ms ScopeSpans) getOrig() *otlptrace.ScopeSpans { + return ms.orig +} + +func (ms ScopeSpans) getState() *internal.State { + return ms.state +} + // Scope returns the scope associated with this ScopeSpans. func (ms ScopeSpans) Scope() pcommon.InstrumentationScope { return pcommon.InstrumentationScope(internal.NewInstrumentationScope(&ms.orig.Scope, ms.state)) diff --git a/pdata/ptrace/generated_scopespansslice.go b/pdata/ptrace/generated_scopespansslice.go index 8fd0b4b8e99..257d992df98 100644 --- a/pdata/ptrace/generated_scopespansslice.go +++ b/pdata/ptrace/generated_scopespansslice.go @@ -29,6 +29,14 @@ func newScopeSpansSlice(orig *[]*otlptrace.ScopeSpans, state *internal.State) Sc return ScopeSpansSlice{orig: orig, state: state} } +func (ms ScopeSpansSlice) getOrig() *[]*otlptrace.ScopeSpans { + return ms.orig +} + +func (ms ScopeSpansSlice) getState() *internal.State { + return ms.state +} + // NewScopeSpansSlice creates a ScopeSpansSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewScopeSpansSlice() ScopeSpansSlice { @@ -41,7 +49,7 @@ func NewScopeSpansSlice() ScopeSpansSlice { // // Returns "0" for a newly instance created with "NewScopeSpansSlice()". func (es ScopeSpansSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es ScopeSpansSlice) Len() int { // ... // Do something with the element // } func (es ScopeSpansSlice) At(i int) ScopeSpans { - return newScopeSpans((*es.orig)[i], es.state) + return newScopeSpans((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es ScopeSpansSlice) At(i int) ScopeSpans { // // Here should set all the values for e. // } func (es ScopeSpansSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlptrace.ScopeSpans, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlptrace.ScopeSpans, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty ScopeSpans. // It returns the newly added ScopeSpans. func (es ScopeSpansSlice) AppendEmpty() ScopeSpans { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlptrace.ScopeSpans{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlptrace.ScopeSpans{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es ScopeSpansSlice) MoveAndAppendTo(dest ScopeSpansSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es ScopeSpansSlice) RemoveIf(f func(ScopeSpans) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es ScopeSpansSlice) RemoveIf(f func(ScopeSpans) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es ScopeSpansSlice) CopyTo(dest ScopeSpansSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newScopeSpans((*es.orig)[i], es.state).CopyTo(newScopeSpans((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newScopeSpans((*es.getOrig())[i], es.getState()).CopyTo(newScopeSpans((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlptrace.ScopeSpans, srcLen) wrappers := make([]*otlptrace.ScopeSpans, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newScopeSpans((*es.orig)[i], es.state).CopyTo(newScopeSpans(wrappers[i], dest.state)) + newScopeSpans((*es.getOrig())[i], es.getState()).CopyTo(newScopeSpans(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the ScopeSpans elements within ScopeSpansSlice given the // provided less function so that two instances of ScopeSpansSlice // can be compared. func (es ScopeSpansSlice) Sort(less func(a, b ScopeSpans) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/ptrace/generated_scopespansslice_test.go b/pdata/ptrace/generated_scopespansslice_test.go index f7594580658..e6f97509530 100644 --- a/pdata/ptrace/generated_scopespansslice_test.go +++ b/pdata/ptrace/generated_scopespansslice_test.go @@ -69,14 +69,14 @@ func TestScopeSpansSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestScopeSpansSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestScopeSpansSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestScopeSpansSlice(), es) } @@ -126,16 +126,16 @@ func TestScopeSpansSlice_RemoveIf(t *testing.T) { func TestScopeSpansSlice_Sort(t *testing.T) { es := generateTestScopeSpansSlice() es.Sort(func(a, b ScopeSpans) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b ScopeSpans) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/ptrace/generated_span.go b/pdata/ptrace/generated_span.go index 56a701974c4..610e548e337 100644 --- a/pdata/ptrace/generated_span.go +++ b/pdata/ptrace/generated_span.go @@ -48,6 +48,14 @@ func (ms Span) MoveTo(dest Span) { *ms.orig = otlptrace.Span{} } +func (ms Span) getOrig() *otlptrace.Span { + return ms.orig +} + +func (ms Span) getState() *internal.State { + return ms.state +} + // TraceID returns the traceid associated with this Span. func (ms Span) TraceID() pcommon.TraceID { return pcommon.TraceID(ms.orig.TraceId) diff --git a/pdata/ptrace/generated_spanevent.go b/pdata/ptrace/generated_spanevent.go index a35c88ae93d..167e614bcde 100644 --- a/pdata/ptrace/generated_spanevent.go +++ b/pdata/ptrace/generated_spanevent.go @@ -47,6 +47,14 @@ func (ms SpanEvent) MoveTo(dest SpanEvent) { *ms.orig = otlptrace.Span_Event{} } +func (ms SpanEvent) getOrig() *otlptrace.Span_Event { + return ms.orig +} + +func (ms SpanEvent) getState() *internal.State { + return ms.state +} + // Timestamp returns the timestamp associated with this SpanEvent. func (ms SpanEvent) Timestamp() pcommon.Timestamp { return pcommon.Timestamp(ms.orig.TimeUnixNano) diff --git a/pdata/ptrace/generated_spaneventslice.go b/pdata/ptrace/generated_spaneventslice.go index ffde17c83a2..ac5bb503906 100644 --- a/pdata/ptrace/generated_spaneventslice.go +++ b/pdata/ptrace/generated_spaneventslice.go @@ -29,6 +29,14 @@ func newSpanEventSlice(orig *[]*otlptrace.Span_Event, state *internal.State) Spa return SpanEventSlice{orig: orig, state: state} } +func (ms SpanEventSlice) getOrig() *[]*otlptrace.Span_Event { + return ms.orig +} + +func (ms SpanEventSlice) getState() *internal.State { + return ms.state +} + // NewSpanEventSlice creates a SpanEventSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewSpanEventSlice() SpanEventSlice { @@ -41,7 +49,7 @@ func NewSpanEventSlice() SpanEventSlice { // // Returns "0" for a newly instance created with "NewSpanEventSlice()". func (es SpanEventSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es SpanEventSlice) Len() int { // ... // Do something with the element // } func (es SpanEventSlice) At(i int) SpanEvent { - return newSpanEvent((*es.orig)[i], es.state) + return newSpanEvent((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es SpanEventSlice) At(i int) SpanEvent { // // Here should set all the values for e. // } func (es SpanEventSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlptrace.Span_Event, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlptrace.Span_Event, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty SpanEvent. // It returns the newly added SpanEvent. func (es SpanEventSlice) AppendEmpty() SpanEvent { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlptrace.Span_Event{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlptrace.Span_Event{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es SpanEventSlice) MoveAndAppendTo(dest SpanEventSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es SpanEventSlice) RemoveIf(f func(SpanEvent) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es SpanEventSlice) RemoveIf(f func(SpanEvent) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es SpanEventSlice) CopyTo(dest SpanEventSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newSpanEvent((*es.orig)[i], es.state).CopyTo(newSpanEvent((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newSpanEvent((*es.getOrig())[i], es.getState()).CopyTo(newSpanEvent((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlptrace.Span_Event, srcLen) wrappers := make([]*otlptrace.Span_Event, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newSpanEvent((*es.orig)[i], es.state).CopyTo(newSpanEvent(wrappers[i], dest.state)) + newSpanEvent((*es.getOrig())[i], es.getState()).CopyTo(newSpanEvent(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the SpanEvent elements within SpanEventSlice given the // provided less function so that two instances of SpanEventSlice // can be compared. func (es SpanEventSlice) Sort(less func(a, b SpanEvent) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/ptrace/generated_spaneventslice_test.go b/pdata/ptrace/generated_spaneventslice_test.go index 7da302ec805..58b32236280 100644 --- a/pdata/ptrace/generated_spaneventslice_test.go +++ b/pdata/ptrace/generated_spaneventslice_test.go @@ -69,14 +69,14 @@ func TestSpanEventSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestSpanEventSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestSpanEventSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestSpanEventSlice(), es) } @@ -126,16 +126,16 @@ func TestSpanEventSlice_RemoveIf(t *testing.T) { func TestSpanEventSlice_Sort(t *testing.T) { es := generateTestSpanEventSlice() es.Sort(func(a, b SpanEvent) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b SpanEvent) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/ptrace/generated_spanlink.go b/pdata/ptrace/generated_spanlink.go index 3121e263e23..4ecee1335ed 100644 --- a/pdata/ptrace/generated_spanlink.go +++ b/pdata/ptrace/generated_spanlink.go @@ -49,6 +49,14 @@ func (ms SpanLink) MoveTo(dest SpanLink) { *ms.orig = otlptrace.Span_Link{} } +func (ms SpanLink) getOrig() *otlptrace.Span_Link { + return ms.orig +} + +func (ms SpanLink) getState() *internal.State { + return ms.state +} + // TraceID returns the traceid associated with this SpanLink. func (ms SpanLink) TraceID() pcommon.TraceID { return pcommon.TraceID(ms.orig.TraceId) diff --git a/pdata/ptrace/generated_spanlinkslice.go b/pdata/ptrace/generated_spanlinkslice.go index 164038b8bed..30735803483 100644 --- a/pdata/ptrace/generated_spanlinkslice.go +++ b/pdata/ptrace/generated_spanlinkslice.go @@ -29,6 +29,14 @@ func newSpanLinkSlice(orig *[]*otlptrace.Span_Link, state *internal.State) SpanL return SpanLinkSlice{orig: orig, state: state} } +func (ms SpanLinkSlice) getOrig() *[]*otlptrace.Span_Link { + return ms.orig +} + +func (ms SpanLinkSlice) getState() *internal.State { + return ms.state +} + // NewSpanLinkSlice creates a SpanLinkSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewSpanLinkSlice() SpanLinkSlice { @@ -41,7 +49,7 @@ func NewSpanLinkSlice() SpanLinkSlice { // // Returns "0" for a newly instance created with "NewSpanLinkSlice()". func (es SpanLinkSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es SpanLinkSlice) Len() int { // ... // Do something with the element // } func (es SpanLinkSlice) At(i int) SpanLink { - return newSpanLink((*es.orig)[i], es.state) + return newSpanLink((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es SpanLinkSlice) At(i int) SpanLink { // // Here should set all the values for e. // } func (es SpanLinkSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlptrace.Span_Link, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlptrace.Span_Link, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty SpanLink. // It returns the newly added SpanLink. func (es SpanLinkSlice) AppendEmpty() SpanLink { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlptrace.Span_Link{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlptrace.Span_Link{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es SpanLinkSlice) MoveAndAppendTo(dest SpanLinkSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es SpanLinkSlice) RemoveIf(f func(SpanLink) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es SpanLinkSlice) RemoveIf(f func(SpanLink) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es SpanLinkSlice) CopyTo(dest SpanLinkSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newSpanLink((*es.orig)[i], es.state).CopyTo(newSpanLink((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newSpanLink((*es.getOrig())[i], es.getState()).CopyTo(newSpanLink((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlptrace.Span_Link, srcLen) wrappers := make([]*otlptrace.Span_Link, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newSpanLink((*es.orig)[i], es.state).CopyTo(newSpanLink(wrappers[i], dest.state)) + newSpanLink((*es.getOrig())[i], es.getState()).CopyTo(newSpanLink(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the SpanLink elements within SpanLinkSlice given the // provided less function so that two instances of SpanLinkSlice // can be compared. func (es SpanLinkSlice) Sort(less func(a, b SpanLink) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/ptrace/generated_spanlinkslice_test.go b/pdata/ptrace/generated_spanlinkslice_test.go index 95606c26c0c..787f9e3c544 100644 --- a/pdata/ptrace/generated_spanlinkslice_test.go +++ b/pdata/ptrace/generated_spanlinkslice_test.go @@ -69,14 +69,14 @@ func TestSpanLinkSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestSpanLinkSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestSpanLinkSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestSpanLinkSlice(), es) } @@ -126,16 +126,16 @@ func TestSpanLinkSlice_RemoveIf(t *testing.T) { func TestSpanLinkSlice_Sort(t *testing.T) { es := generateTestSpanLinkSlice() es.Sort(func(a, b SpanLink) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b SpanLink) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/ptrace/generated_spanslice.go b/pdata/ptrace/generated_spanslice.go index 654a547523f..7080f64adb7 100644 --- a/pdata/ptrace/generated_spanslice.go +++ b/pdata/ptrace/generated_spanslice.go @@ -29,6 +29,14 @@ func newSpanSlice(orig *[]*otlptrace.Span, state *internal.State) SpanSlice { return SpanSlice{orig: orig, state: state} } +func (ms SpanSlice) getOrig() *[]*otlptrace.Span { + return ms.orig +} + +func (ms SpanSlice) getState() *internal.State { + return ms.state +} + // NewSpanSlice creates a SpanSlice with 0 elements. // Can use "EnsureCapacity" to initialize with a given capacity. func NewSpanSlice() SpanSlice { @@ -41,7 +49,7 @@ func NewSpanSlice() SpanSlice { // // Returns "0" for a newly instance created with "NewSpanSlice()". func (es SpanSlice) Len() int { - return len(*es.orig) + return len(*es.getOrig()) } // At returns the element at the given index. @@ -53,7 +61,7 @@ func (es SpanSlice) Len() int { // ... // Do something with the element // } func (es SpanSlice) At(i int) Span { - return newSpan((*es.orig)[i], es.state) + return newSpan((*es.getOrig())[i], es.getState()) } // EnsureCapacity is an operation that ensures the slice has at least the specified capacity. @@ -69,45 +77,45 @@ func (es SpanSlice) At(i int) Span { // // Here should set all the values for e. // } func (es SpanSlice) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.getState().AssertMutable() + oldCap := cap(*es.getOrig()) if newCap <= oldCap { return } - newOrig := make([]*otlptrace.Span, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]*otlptrace.Span, len(*es.getOrig()), newCap) + copy(newOrig, *es.getOrig()) + *es.getOrig() = newOrig } // AppendEmpty will append to the end of the slice an empty Span. // It returns the newly added Span. func (es SpanSlice) AppendEmpty() Span { - es.state.AssertMutable() - *es.orig = append(*es.orig, &otlptrace.Span{}) + es.getState().AssertMutable() + *es.getOrig() = append(*es.getOrig(), &otlptrace.Span{}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es SpanSlice) MoveAndAppendTo(dest SpanSlice) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.getState().AssertMutable() + dest.getState().AssertMutable() + if *dest.getOrig() == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.getOrig() = *es.getOrig() } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.getOrig() = append(*dest.getOrig(), *es.getOrig()...) } - *es.orig = nil + *es.getOrig() = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es SpanSlice) RemoveIf(f func(Span) bool) { - es.state.AssertMutable() + es.getState().AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.getOrig()); i++ { if f(es.At(i)) { continue } @@ -116,37 +124,37 @@ func (es SpanSlice) RemoveIf(f func(Span) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.getOrig())[newLen] = (*es.getOrig())[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.getOrig() = (*es.getOrig())[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es SpanSlice) CopyTo(dest SpanSlice) { - dest.state.AssertMutable() + dest.getState().AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.getOrig()) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] - for i := range *es.orig { - newSpan((*es.orig)[i], es.state).CopyTo(newSpan((*dest.orig)[i], dest.state)) + (*dest.getOrig()) = (*dest.getOrig())[:srcLen:destCap] + for i := range *es.getOrig() { + newSpan((*es.getOrig())[i], es.getState()).CopyTo(newSpan((*dest.getOrig())[i], dest.getState())) } return } origs := make([]otlptrace.Span, srcLen) wrappers := make([]*otlptrace.Span, srcLen) - for i := range *es.orig { + for i := range *es.getOrig() { wrappers[i] = &origs[i] - newSpan((*es.orig)[i], es.state).CopyTo(newSpan(wrappers[i], dest.state)) + newSpan((*es.getOrig())[i], es.getState()).CopyTo(newSpan(wrappers[i], dest.getState())) } - *dest.orig = wrappers + *dest.getOrig() = wrappers } // Sort sorts the Span elements within SpanSlice given the // provided less function so that two instances of SpanSlice // can be compared. func (es SpanSlice) Sort(less func(a, b Span) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.getState().AssertMutable() + sort.SliceStable(*es.getOrig(), func(i, j int) bool { return less(es.At(i), es.At(j)) }) } diff --git a/pdata/ptrace/generated_spanslice_test.go b/pdata/ptrace/generated_spanslice_test.go index e8d9e66b161..7c3ee3a296f 100644 --- a/pdata/ptrace/generated_spanslice_test.go +++ b/pdata/ptrace/generated_spanslice_test.go @@ -69,14 +69,14 @@ func TestSpanSlice_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.getOrig())) assert.Equal(t, generateTestSpanSlice(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTestSpanSlice().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.getOrig())) assert.Equal(t, generateTestSpanSlice(), es) } @@ -126,16 +126,16 @@ func TestSpanSlice_RemoveIf(t *testing.T) { func TestSpanSlice_Sort(t *testing.T) { es := generateTestSpanSlice() es.Sort(func(a, b Span) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) < uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } es.Sort(func(a, b Span) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.getOrig())) > uintptr(unsafe.Pointer(b.getOrig())) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).getOrig())), uintptr(unsafe.Pointer(es.At(i).getOrig()))) } } diff --git a/pdata/ptrace/generated_status.go b/pdata/ptrace/generated_status.go index 2b3e66a92d0..00f094f070e 100644 --- a/pdata/ptrace/generated_status.go +++ b/pdata/ptrace/generated_status.go @@ -46,6 +46,14 @@ func (ms Status) MoveTo(dest Status) { *ms.orig = otlptrace.Status{} } +func (ms Status) getOrig() *otlptrace.Status { + return ms.orig +} + +func (ms Status) getState() *internal.State { + return ms.state +} + // Code returns the code associated with this Status. func (ms Status) Code() StatusCode { return StatusCode(ms.orig.Code) diff --git a/pdata/ptrace/ptraceotlp/generated_exportpartialsuccess.go b/pdata/ptrace/ptraceotlp/generated_exportpartialsuccess.go index 50cf0c805e8..724882cbb1b 100644 --- a/pdata/ptrace/ptraceotlp/generated_exportpartialsuccess.go +++ b/pdata/ptrace/ptraceotlp/generated_exportpartialsuccess.go @@ -45,6 +45,14 @@ func (ms ExportPartialSuccess) MoveTo(dest ExportPartialSuccess) { *ms.orig = otlpcollectortrace.ExportTracePartialSuccess{} } +func (ms ExportPartialSuccess) getOrig() *otlpcollectortrace.ExportTracePartialSuccess { + return ms.orig +} + +func (ms ExportPartialSuccess) getState() *internal.State { + return ms.state +} + // RejectedSpans returns the rejectedspans associated with this ExportPartialSuccess. func (ms ExportPartialSuccess) RejectedSpans() int64 { return ms.orig.RejectedSpans diff --git a/processor/internal/entities.go b/processor/internal/entities.go new file mode 100644 index 00000000000..8932a68fb8e --- /dev/null +++ b/processor/internal/entities.go @@ -0,0 +1,15 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package internal // import "go.opentelemetry.io/collector/processor/internal" + +import ( + "go.opentelemetry.io/collector/component" + "go.opentelemetry.io/collector/consumer" +) + +// Entities is a processor that can consume profiles. +type Entities interface { + component.Component + consumer.Entities +} diff --git a/processor/processor.go b/processor/processor.go index ea12c98f0b4..2a5121288a5 100644 --- a/processor/processor.go +++ b/processor/processor.go @@ -30,6 +30,12 @@ type Logs interface { consumer.Logs } +// Entities is a processor that can consume entities. +type Entities interface { + component.Component + consumer.Entities +} + // Settings is passed to Create* functions in Factory. type Settings struct { // ID returns the ID of the component that will be created. @@ -93,6 +99,15 @@ type Factory interface { // Deprecated: [v0.111.0] use LogsStability. LogsProcessorStability() component.StabilityLevel + // CreateEntities creates an Entities processor based on this config. + // If the processor type does not support entities, + // this function returns the error [pipeline.ErrSignalNotSupported]. + // Implementers can assume `next` is never nil. + CreateEntities(ctx context.Context, set Settings, cfg component.Config, next consumer.Entities) (Entities, error) + + // EntitiesStability gets the stability level of the Entities processor. + EntitiesStability() component.StabilityLevel + unexportedFactoryFunc() } @@ -120,6 +135,8 @@ type factory struct { metricsStabilityLevel component.StabilityLevel CreateLogsFunc logsStabilityLevel component.StabilityLevel + CreateEntitiesFunc + entitiesStabilityLevel component.StabilityLevel } func (f *factory) Type() component.Type { @@ -155,6 +172,10 @@ func (f factory) LogsProcessorStability() component.StabilityLevel { return f.logsStabilityLevel } +func (f factory) EntitiesStability() component.StabilityLevel { + return f.entitiesStabilityLevel +} + // CreateTracesFunc is the equivalent of Factory.CreateTraces(). type CreateTracesFunc func(context.Context, Settings, component.Config, consumer.Traces) (Traces, error) @@ -203,6 +224,17 @@ func (f CreateLogsFunc) CreateLogsProcessor(ctx context.Context, set Settings, c return f.CreateLogs(ctx, set, cfg, next) } +// CreateEntitiesFunc is the equivalent of Factory.CreateEntities(). +type CreateEntitiesFunc func(context.Context, Settings, component.Config, consumer.Entities) (Entities, error) + +// CreateEntities implements Factory.CreateEntities. +func (f CreateEntitiesFunc) CreateEntities(ctx context.Context, set Settings, cfg component.Config, next consumer.Entities) (Entities, error) { + if f == nil { + return nil, pipeline.ErrSignalNotSupported + } + return f(ctx, set, cfg, next) +} + // WithTraces overrides the default "error not supported" implementation for CreateTraces and the default "undefined" stability level. func WithTraces(createTraces CreateTracesFunc, sl component.StabilityLevel) FactoryOption { return factoryOptionFunc(func(o *factory) { @@ -227,6 +259,14 @@ func WithLogs(createLogs CreateLogsFunc, sl component.StabilityLevel) FactoryOpt }) } +// WithEntities overrides the default "error not supported" implementation for CreateEntities and the default "undefined" stability level. +func WithEntities(createEntities CreateEntitiesFunc, sl component.StabilityLevel) FactoryOption { + return factoryOptionFunc(func(o *factory) { + o.entitiesStabilityLevel = sl + o.CreateEntitiesFunc = createEntities + }) +} + // NewFactory returns a Factory. func NewFactory(cfgType component.Type, createDefaultConfig component.CreateDefaultConfigFunc, options ...FactoryOption) Factory { f := &factory{ diff --git a/processor/processor_test.go b/processor/processor_test.go index 79fd2cb6aa6..80e94e30b12 100644 --- a/processor/processor_test.go +++ b/processor/processor_test.go @@ -29,6 +29,8 @@ func TestNewFactory(t *testing.T) { require.Error(t, err) _, err = factory.CreateLogs(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop()) assert.Error(t, err) + _, err = factory.CreateEntities(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop()) + assert.Error(t, err) } func TestNewFactoryWithOptions(t *testing.T) { diff --git a/receiver/receiver.go b/receiver/receiver.go index 786071a352d..157a5246ab8 100644 --- a/receiver/receiver.go +++ b/receiver/receiver.go @@ -39,6 +39,15 @@ type Logs interface { component.Component } +// Entities receiver receives entities. +// Its purpose is to translate data from any format to the collector's internal entities data format. +// EntitiesReceiver feeds a consumer.Entities with data. +// +// For example, it could be a receiver that reads sysentities and convert them into plog.Entities. +type Entities interface { + component.Component +} + // Settings configures Receiver creators. type Settings struct { // ID returns the ID of the component that will be created. @@ -102,6 +111,14 @@ type Factory interface { // Deprecated: [v0.111.0] Use LogsStability. LogsReceiverStability() component.StabilityLevel + // CreateEntitiesReceiver creates a EntitiesReceiver based on this config. + // If the receiver type does not support the data type or if the config is not valid + // an error will be returned instead. + CreateEntitiesReceiver(ctx context.Context, set Settings, cfg component.Config, nextConsumer consumer.Entities) (Entities, error) + + // EntitiesReceiverStability gets the stability level of the EntitiesReceiver. + EntitiesReceiverStability() component.StabilityLevel + unexportedFactoryFunc() } @@ -166,6 +183,22 @@ func (f CreateLogsFunc) CreateLogsReceiver(ctx context.Context, set Settings, cf return f.CreateLogs(ctx, set, cfg, next) } +// CreateEntitiesFunc is the equivalent of ReceiverFactory.CreateEntitiesReceiver(). +type CreateEntitiesFunc func(context.Context, Settings, component.Config, consumer.Entities) (Entities, error) + +// CreateEntitiesReceiver implements Factory.CreateEntitiesReceiver(). +func (f CreateEntitiesFunc) CreateEntitiesReceiver( + ctx context.Context, + set Settings, + cfg component.Config, + nextConsumer consumer.Entities, +) (Entities, error) { + if f == nil { + return nil, pipeline.ErrSignalNotSupported + } + return f(ctx, set, cfg, nextConsumer) +} + type factory struct { cfgType component.Type component.CreateDefaultConfigFunc @@ -175,6 +208,8 @@ type factory struct { metricsStabilityLevel component.StabilityLevel CreateLogsFunc logsStabilityLevel component.StabilityLevel + CreateEntitiesFunc + entitiesStabilityLevel component.StabilityLevel } func (f *factory) Type() component.Type { @@ -210,7 +245,11 @@ func (f *factory) LogsReceiverStability() component.StabilityLevel { return f.LogsStability() } -// WithTraces overrides the default "error not supported" implementation for Factory.CreateTraces and the default "undefined" stability level. +func (f *factory) EntitiesReceiverStability() component.StabilityLevel { + return f.entitiesStabilityLevel +} + +// WithTraces overrides the default "error not supported" implementation for CreateTracesReceiver and the default "undefined" stability level. func WithTraces(createTraces CreateTracesFunc, sl component.StabilityLevel) FactoryOption { return factoryOptionFunc(func(o *factory) { o.tracesStabilityLevel = sl @@ -234,6 +273,14 @@ func WithLogs(createLogs CreateLogsFunc, sl component.StabilityLevel) FactoryOpt }) } +// WithEntities overrides the default "error not supported" implementation for CreateEntitiesReceiver and the default "undefined" stability level. +func WithEntities(createEntities CreateEntitiesFunc, sl component.StabilityLevel) FactoryOption { + return factoryOptionFunc(func(o *factory) { + o.entitiesStabilityLevel = sl + o.CreateEntitiesFunc = createEntities + }) +} + // NewFactory returns a Factory. func NewFactory(cfgType component.Type, createDefaultConfig component.CreateDefaultConfigFunc, options ...FactoryOption) Factory { f := &factory{