From e08c6fd6de8cff8cd018803cdf779f223c3c32e5 Mon Sep 17 00:00:00 2001
From: Jacob Aronoff <jacobaronoff45@gmail.com>
Date: Mon, 15 Apr 2024 12:00:45 -0400
Subject: [PATCH 1/6] checkpoint: with working tests, minimal

---
 apis/v1beta1/config.go                        | 77 +++++++++++++++----
 apis/v1beta1/config_test.go                   | 26 +++++++
 apis/v1beta1/zz_generated.deepcopy.go         | 47 +++++++++++
 .../collector/adapters/config_to_ports.go     | 28 ++-----
 .../adapters/config_to_ports_test.go          | 69 ++++++++---------
 internal/manifests/collector/container.go     |  8 +-
 internal/manifests/collector/service.go       | 13 +---
 7 files changed, 177 insertions(+), 91 deletions(-)

diff --git a/apis/v1beta1/config.go b/apis/v1beta1/config.go
index a34a8cacfd..04695cefa9 100644
--- a/apis/v1beta1/config.go
+++ b/apis/v1beta1/config.go
@@ -30,10 +30,10 @@ type AnyConfig struct {
 }
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *AnyConfig) DeepCopyInto(out *AnyConfig) {
-	*out = *in
-	if in.Object != nil {
-		in, out := &in.Object, &out.Object
+func (c *AnyConfig) DeepCopyInto(out *AnyConfig) {
+	*out = *c
+	if c.Object != nil {
+		in, out := &c.Object, &out.Object
 		*out = make(map[string]interface{}, len(*in))
 		for key, val := range *in {
 			(*out)[key] = val
@@ -42,12 +42,12 @@ func (in *AnyConfig) DeepCopyInto(out *AnyConfig) {
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnyConfig.
-func (in *AnyConfig) DeepCopy() *AnyConfig {
-	if in == nil {
+func (c *AnyConfig) DeepCopy() *AnyConfig {
+	if c == nil {
 		return nil
 	}
 	out := new(AnyConfig)
-	in.DeepCopyInto(out)
+	c.DeepCopyInto(out)
 	return out
 }
 
@@ -88,7 +88,7 @@ type Config struct {
 }
 
 // Yaml encodes the current object and returns it as a string.
-func (c Config) Yaml() (string, error) {
+func (c *Config) Yaml() (string, error) {
 	var buf bytes.Buffer
 	yamlEncoder := yaml.NewEncoder(&buf)
 	yamlEncoder.SetIndent(2)
@@ -98,16 +98,8 @@ func (c Config) Yaml() (string, error) {
 	return buf.String(), nil
 }
 
-type Service struct {
-	Extensions *[]string `json:"extensions,omitempty" yaml:"extensions,omitempty"`
-	// +kubebuilder:pruning:PreserveUnknownFields
-	Telemetry *AnyConfig `json:"telemetry,omitempty" yaml:"telemetry,omitempty"`
-	// +kubebuilder:pruning:PreserveUnknownFields
-	Pipelines AnyConfig `json:"pipelines" yaml:"pipelines"`
-}
-
 // Returns null objects in the config.
-func (c Config) nullObjects() []string {
+func (c *Config) nullObjects() []string {
 	var nullKeys []string
 	if nulls := hasNullValue(c.Receivers.Object); len(nulls) > 0 {
 		nullKeys = append(nullKeys, addPrefix("receivers.", nulls)...)
@@ -135,6 +127,57 @@ func (c Config) nullObjects() []string {
 	return nullKeys
 }
 
+type Service struct {
+	Extensions *[]string `json:"extensions,omitempty" yaml:"extensions,omitempty"`
+	// +kubebuilder:pruning:PreserveUnknownFields
+	Telemetry *AnyConfig `json:"telemetry,omitempty" yaml:"telemetry,omitempty"`
+	// +kubebuilder:pruning:PreserveUnknownFields
+	Pipelines AnyConfig `json:"pipelines" yaml:"pipelines"`
+}
+
+// MetricsConfig comes from the collector.
+type MetricsConfig struct {
+	// Level is the level of telemetry metrics, the possible values are:
+	//  - "none" indicates that no telemetry data should be collected;
+	//  - "basic" is the recommended and covers the basics of the service telemetry.
+	//  - "normal" adds some other indicators on top of basic.
+	//  - "detailed" adds dimensions and views to the previous levels.
+	Level string `json:"level,omitempty" yaml:"level,omitempty"`
+
+	// Address is the [address]:port that metrics exposition should be bound to.
+	Address string `json:"address,omitempty" yaml:"address,omitempty"`
+}
+
+// Telemetry is an intermediary type that allows for easy access to the collector's telemetry settings.
+type Telemetry struct {
+	Metrics MetricsConfig `json:"metrics,omitempty" yaml:"metrics,omitempty"`
+
+	// Resource specifies user-defined attributes to include with all emitted telemetry.
+	// Note that some attributes are added automatically (e.g. service.version) even
+	// if they are not specified here. In order to suppress such attributes the
+	// attribute must be specified in this map with null YAML value (nil string pointer).
+	Resource map[string]*string `json:"resource,omitempty" yaml:"resource,omitempty"`
+}
+
+// GetTelemetry serves as a helper function to access the fields we care about in the underlying telemetry struct.
+// This exists to avoid needing to worry extra fields in the telemetry struct.
+func (s *Service) GetTelemetry() *Telemetry {
+	if s.Telemetry == nil {
+		return nil
+	}
+	// Convert map to JSON bytes
+	jsonData, err := json.Marshal(s.Telemetry)
+	if err != nil {
+		return nil
+	}
+	t := &Telemetry{}
+	// Unmarshal JSON into the provided struct
+	if err := json.Unmarshal(jsonData, t); err != nil {
+		return nil
+	}
+	return t
+}
+
 func hasNullValue(cfg map[string]interface{}) []string {
 	var nullKeys []string
 	for k, v := range cfg {
diff --git a/apis/v1beta1/config_test.go b/apis/v1beta1/config_test.go
index ac067f9ea1..207a61133a 100644
--- a/apis/v1beta1/config_test.go
+++ b/apis/v1beta1/config_test.go
@@ -184,3 +184,29 @@ service:
 
 	assert.Equal(t, expected, yamlCollector)
 }
+
+func TestGetTelemetryFromYAML(t *testing.T) {
+	collectorYaml, err := os.ReadFile("./testdata/otelcol-demo.yaml")
+	require.NoError(t, err)
+
+	cfg := &Config{}
+	err = go_yaml.Unmarshal(collectorYaml, cfg)
+	require.NoError(t, err)
+	telemetry := &Telemetry{
+		Metrics: MetricsConfig{
+			Level:   "detailed",
+			Address: "0.0.0.0:8888",
+		},
+	}
+	assert.Equal(t, telemetry, cfg.Service.GetTelemetry())
+}
+
+func TestGetTelemetryFromYAMLIsNil(t *testing.T) {
+	collectorYaml, err := os.ReadFile("./testdata/otelcol-couchbase.yaml")
+	require.NoError(t, err)
+
+	cfg := &Config{}
+	err = go_yaml.Unmarshal(collectorYaml, cfg)
+	require.NoError(t, err)
+	assert.Nil(t, cfg.Service.GetTelemetry())
+}
diff --git a/apis/v1beta1/zz_generated.deepcopy.go b/apis/v1beta1/zz_generated.deepcopy.go
index e109e8ff7a..80cddf7dd0 100644
--- a/apis/v1beta1/zz_generated.deepcopy.go
+++ b/apis/v1beta1/zz_generated.deepcopy.go
@@ -174,6 +174,21 @@ func (in *MetricSpec) DeepCopy() *MetricSpec {
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *MetricsConfig) DeepCopyInto(out *MetricsConfig) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricsConfig.
+func (in *MetricsConfig) DeepCopy() *MetricsConfig {
+	if in == nil {
+		return nil
+	}
+	out := new(MetricsConfig)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *MetricsConfigSpec) DeepCopyInto(out *MetricsConfigSpec) {
 	*out = *in
@@ -804,3 +819,35 @@ func (in *TargetAllocatorStatus) DeepCopy() *TargetAllocatorStatus {
 	in.DeepCopyInto(out)
 	return out
 }
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Telemetry) DeepCopyInto(out *Telemetry) {
+	*out = *in
+	out.Metrics = in.Metrics
+	if in.Resource != nil {
+		in, out := &in.Resource, &out.Resource
+		*out = make(map[string]*string, len(*in))
+		for key, val := range *in {
+			var outVal *string
+			if val == nil {
+				(*out)[key] = nil
+			} else {
+				inVal := (*in)[key]
+				in, out := &inVal, &outVal
+				*out = new(string)
+				**out = **in
+			}
+			(*out)[key] = outVal
+		}
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Telemetry.
+func (in *Telemetry) DeepCopy() *Telemetry {
+	if in == nil {
+		return nil
+	}
+	out := new(Telemetry)
+	in.DeepCopyInto(out)
+	return out
+}
diff --git a/internal/manifests/collector/adapters/config_to_ports.go b/internal/manifests/collector/adapters/config_to_ports.go
index 3a0bc5a6fd..0a8b183d4f 100644
--- a/internal/manifests/collector/adapters/config_to_ports.go
+++ b/internal/manifests/collector/adapters/config_to_ports.go
@@ -22,7 +22,6 @@ import (
 	"strings"
 
 	"github.com/go-logr/logr"
-	"github.com/mitchellh/mapstructure"
 	corev1 "k8s.io/api/core/v1"
 
 	"github.com/open-telemetry/opentelemetry-operator/apis/v1beta1"
@@ -153,29 +152,12 @@ func ConfigToPorts(logger logr.Logger, config map[interface{}]interface{}) ([]v1
 }
 
 // ConfigToMetricsPort gets the port number for the metrics endpoint from the collector config if it has been set.
-func ConfigToMetricsPort(logger logr.Logger, config map[interface{}]interface{}) (int32, error) {
-	// we don't need to unmarshal the whole config, just follow the keys down to
-	// the metrics address.
-	type metricsCfg struct {
-		Address string
-	}
-	type telemetryCfg struct {
-		Metrics metricsCfg
-	}
-	type serviceCfg struct {
-		Telemetry telemetryCfg
-	}
-	type cfg struct {
-		Service serviceCfg
-	}
-
-	var cOut cfg
-	err := mapstructure.Decode(config, &cOut)
-	if err != nil {
-		return 0, err
+func ConfigToMetricsPort(config v1beta1.Service) (int32, error) {
+	if config.GetTelemetry() == nil {
+		// telemetry isn't set, use the default
+		return 8888, nil
 	}
-
-	_, port, netErr := net.SplitHostPort(cOut.Service.Telemetry.Metrics.Address)
+	_, port, netErr := net.SplitHostPort(config.GetTelemetry().Metrics.Address)
 	if netErr != nil && strings.Contains(netErr.Error(), "missing port in address") {
 		return 8888, nil
 	} else if netErr != nil {
diff --git a/internal/manifests/collector/adapters/config_to_ports_test.go b/internal/manifests/collector/adapters/config_to_ports_test.go
index d76091379c..160d998487 100644
--- a/internal/manifests/collector/adapters/config_to_ports_test.go
+++ b/internal/manifests/collector/adapters/config_to_ports_test.go
@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
 
+	"github.com/open-telemetry/opentelemetry-operator/apis/v1beta1"
 	"github.com/open-telemetry/opentelemetry-operator/internal/manifests/collector/adapters"
 	"github.com/open-telemetry/opentelemetry-operator/internal/manifests/collector/parser"
 	"github.com/open-telemetry/opentelemetry-operator/internal/manifests/collector/parser/receiver"
@@ -210,34 +211,33 @@ func TestParserFailed(t *testing.T) {
 	assert.NoError(t, err)
 	assert.True(t, mockParserCalled)
 }
-
 func TestConfigToMetricsPort(t *testing.T) {
-	t.Run("custom port specified", func(t *testing.T) {
-		config := map[interface{}]interface{}{
-			"service": map[interface{}]interface{}{
-				"telemetry": map[interface{}]interface{}{
-					"metrics": map[interface{}]interface{}{
-						"address": "0.0.0.0:9090",
-					},
-				},
-			},
-		}
-
-		port, err := adapters.ConfigToMetricsPort(logger, config)
-		assert.NoError(t, err)
-		assert.Equal(t, int32(9090), port)
-	})
 
 	for _, tt := range []struct {
-		desc   string
-		config map[interface{}]interface{}
+		desc         string
+		expectedPort int32
+		config       v1beta1.Service
 	}{
+		{
+			"custom port",
+			9090,
+			v1beta1.Service{
+				Telemetry: &v1beta1.AnyConfig{
+					Object: map[string]interface{}{
+						"metrics": map[string]interface{}{
+							"address": "0.0.0.0:9090",
+						},
+					},
+				},
+			},
+		},
 		{
 			"bad address",
-			map[interface{}]interface{}{
-				"service": map[interface{}]interface{}{
-					"telemetry": map[interface{}]interface{}{
-						"metrics": map[interface{}]interface{}{
+			8888,
+			v1beta1.Service{
+				Telemetry: &v1beta1.AnyConfig{
+					Object: map[string]interface{}{
+						"metrics": map[string]interface{}{
 							"address": "0.0.0.0",
 						},
 					},
@@ -246,10 +246,11 @@ func TestConfigToMetricsPort(t *testing.T) {
 		},
 		{
 			"missing address",
-			map[interface{}]interface{}{
-				"service": map[interface{}]interface{}{
-					"telemetry": map[interface{}]interface{}{
-						"metrics": map[interface{}]interface{}{
+			8888,
+			v1beta1.Service{
+				Telemetry: &v1beta1.AnyConfig{
+					Object: map[string]interface{}{
+						"metrics": map[string]interface{}{
 							"level": "detailed",
 						},
 					},
@@ -258,24 +259,22 @@ func TestConfigToMetricsPort(t *testing.T) {
 		},
 		{
 			"missing metrics",
-			map[interface{}]interface{}{
-				"service": map[interface{}]interface{}{
-					"telemetry": map[interface{}]interface{}{},
-				},
+			8888,
+			v1beta1.Service{
+				Telemetry: &v1beta1.AnyConfig{},
 			},
 		},
 		{
 			"missing telemetry",
-			map[interface{}]interface{}{
-				"service": map[interface{}]interface{}{},
-			},
+			8888,
+			v1beta1.Service{},
 		},
 	} {
 		t.Run(tt.desc, func(t *testing.T) {
 			// these are acceptable failures, we return to the collector's default metric port
-			port, err := adapters.ConfigToMetricsPort(logger, tt.config)
+			port, err := adapters.ConfigToMetricsPort(tt.config)
 			assert.NoError(t, err)
-			assert.Equal(t, int32(8888), port)
+			assert.Equal(t, tt.expectedPort, port)
 		})
 	}
 }
diff --git a/internal/manifests/collector/container.go b/internal/manifests/collector/container.go
index 1ffd81cbe0..4f5c1b5ef6 100644
--- a/internal/manifests/collector/container.go
+++ b/internal/manifests/collector/container.go
@@ -49,7 +49,7 @@ func Container(cfg config.Config, logger logr.Logger, otelcol v1beta1.OpenTeleme
 	}
 
 	// build container ports from service ports
-	ports, err := getConfigContainerPorts(logger, configYaml)
+	ports, err := getConfigContainerPorts(logger, configYaml, otelcol.Spec.Config)
 	if err != nil {
 		logger.Error(err, "container ports config")
 	}
@@ -169,9 +169,9 @@ func Container(cfg config.Config, logger logr.Logger, otelcol v1beta1.OpenTeleme
 	}
 }
 
-func getConfigContainerPorts(logger logr.Logger, cfg string) (map[string]corev1.ContainerPort, error) {
+func getConfigContainerPorts(logger logr.Logger, cfgYaml string, conf v1beta1.Config) (map[string]corev1.ContainerPort, error) {
 	ports := map[string]corev1.ContainerPort{}
-	c, err := adapters.ConfigFromString(cfg)
+	c, err := adapters.ConfigFromString(cfgYaml)
 	if err != nil {
 		logger.Error(err, "couldn't extract the configuration")
 		return ports, err
@@ -202,7 +202,7 @@ func getConfigContainerPorts(logger logr.Logger, cfg string) (map[string]corev1.
 		}
 	}
 
-	metricsPort, err := adapters.ConfigToMetricsPort(logger, c)
+	metricsPort, err := adapters.ConfigToMetricsPort(conf.Service)
 	if err != nil {
 		logger.Info("couldn't determine metrics port from configuration, using 8888 default value", "error", err)
 		metricsPort = 8888
diff --git a/internal/manifests/collector/service.go b/internal/manifests/collector/service.go
index 7b834bc751..7306943402 100644
--- a/internal/manifests/collector/service.go
+++ b/internal/manifests/collector/service.go
@@ -64,18 +64,7 @@ func MonitoringService(params manifests.Params) (*corev1.Service, error) {
 	labels := manifestutils.Labels(params.OtelCol.ObjectMeta, name, params.OtelCol.Spec.Image, ComponentOpenTelemetryCollector, []string{})
 	labels[monitoringLabel] = valueExists
 
-	out, err := params.OtelCol.Spec.Config.Yaml()
-	if err != nil {
-		return nil, err
-	}
-
-	c, err := adapters.ConfigFromString(out)
-	if err != nil {
-		params.Log.Error(err, "couldn't extract the configuration")
-		return nil, err
-	}
-
-	metricsPort, err := adapters.ConfigToMetricsPort(params.Log, c)
+	metricsPort, err := adapters.ConfigToMetricsPort(params.OtelCol.Spec.Config.Service)
 	if err != nil {
 		return nil, err
 	}

From 334a3d60524191a3446d4d75b0bbbbb8e6b8af7a Mon Sep 17 00:00:00 2001
From: Jacob Aronoff <jacobaronoff45@gmail.com>
Date: Mon, 15 Apr 2024 12:25:32 -0400
Subject: [PATCH 2/6] chlog

---
 .chloggen/2603-part-one.yaml | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100755 .chloggen/2603-part-one.yaml

diff --git a/.chloggen/2603-part-one.yaml b/.chloggen/2603-part-one.yaml
new file mode 100755
index 0000000000..8ff0553b7b
--- /dev/null
+++ b/.chloggen/2603-part-one.yaml
@@ -0,0 +1,16 @@
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. collector, target allocator, auto-instrumentation, opamp, github action)
+component: collector
+
+# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Changes metric port logic to use intermediary struct.
+
+# One or more tracking issues related to the change
+issues: []
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:

From a2cea3c6f9c016d9ba62912a67d4d9205fc189f1 Mon Sep 17 00:00:00 2001
From: Jacob Aronoff <jacobaronoff45@gmail.com>
Date: Mon, 15 Apr 2024 12:26:56 -0400
Subject: [PATCH 3/6] issue

---
 .chloggen/2603-part-one.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.chloggen/2603-part-one.yaml b/.chloggen/2603-part-one.yaml
index 8ff0553b7b..1ed85a6a45 100755
--- a/.chloggen/2603-part-one.yaml
+++ b/.chloggen/2603-part-one.yaml
@@ -8,7 +8,7 @@ component: collector
 note: Changes metric port logic to use intermediary struct.
 
 # One or more tracking issues related to the change
-issues: []
+issues: [2603]
 
 # (Optional) One or more lines of additional information to render under the primary note.
 # These lines will be padded with 2 spaces and then inserted directly into the document.

From d99a94d31052d3b3bf467183324f9da9e6497157 Mon Sep 17 00:00:00 2001
From: Jacob Aronoff <jacobaronoff45@gmail.com>
Date: Mon, 15 Apr 2024 13:30:46 -0400
Subject: [PATCH 4/6] missing change

---
 docs/api.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/api.md b/docs/api.md
index f38a729e4b..842764eab1 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -40457,7 +40457,8 @@ TargetAllocator indicates a value which determines whether to spawn a target all
         <td>
           AllocationStrategy determines which strategy the target allocator should use for allocation.
 The current options are least-weighted, consistent-hashing and per-node. The default is
-consistent-hashing.<br/>
+consistent-hashing.
+WARNING: The per-node strategy currently ignores targets without a Node, like control plane components.<br/>
           <br/>
             <i>Enum</i>: least-weighted, consistent-hashing<br/>
             <i>Default</i>: consistent-hashing<br/>

From 0038aa31ae70ba20d295d029798876a3ac65c48d Mon Sep 17 00:00:00 2001
From: Jacob Aronoff <jacobaronoff45@gmail.com>
Date: Mon, 15 Apr 2024 15:00:27 -0400
Subject: [PATCH 5/6] part two of config marshalling changes

---
 .chloggen/2603-part-two.yaml                  |  16 +++
 .../collector/adapters/config_to_ports.go     |  87 ++++---------
 .../adapters/config_to_ports_test.go          |  74 ++++--------
 .../collector/adapters/config_to_rbac.go      |  27 ++---
 .../collector/adapters/config_to_rbac_test.go |  11 +-
 .../collector/adapters/config_validate.go     | 114 ++++++------------
 .../adapters/config_validate_test.go          |  15 ++-
 internal/manifests/collector/container.go     |  11 +-
 internal/manifests/collector/ingress.go       |  12 +-
 .../collector/parser/exporter/exporter.go     |   6 +-
 .../parser/exporter/exporter_prometheus.go    |   4 +-
 .../parser/exporter/exporter_test.go          |   4 +-
 internal/manifests/collector/parser/parser.go |   5 +-
 .../collector/parser/processor/processor.go   |   4 +-
 .../processor/processor_k8sattributes.go      |   6 +-
 .../processor/processor_k8sattributes_test.go |   6 +-
 .../processor/processor_resourcedetection.go  |   4 +-
 .../collector/parser/receiver/receiver.go     |   6 +-
 .../parser/receiver/receiver_aws-xray.go      |   2 +-
 .../parser/receiver/receiver_carbon.go        |   2 +-
 .../parser/receiver/receiver_collectd.go      |   2 +-
 .../receiver/receiver_fluent-forward.go       |   2 +-
 .../parser/receiver/receiver_generic.go       |   4 +-
 .../parser/receiver/receiver_generic_test.go  |  12 +-
 .../parser/receiver/receiver_influxdb.go      |   2 +-
 .../parser/receiver/receiver_jaeger.go        |  10 +-
 .../parser/receiver/receiver_jaeger_test.go   |  26 ++--
 .../parser/receiver/receiver_loki.go          |  10 +-
 .../parser/receiver/receiver_loki_test.go     |  18 +--
 .../collector/parser/receiver/receiver_oc.go  |   2 +-
 .../parser/receiver/receiver_otlp.go          |  10 +-
 .../parser/receiver/receiver_otlp_test.go     |  18 +--
 .../parser/receiver/receiver_sapm.go          |   2 +-
 .../parser/receiver/receiver_signalfx.go      |   2 +-
 .../parser/receiver/receiver_skywalking.go    |  10 +-
 .../receiver/receiver_skywalking_test.go      |  18 +--
 .../parser/receiver/receiver_splunk-hec.go    |   2 +-
 .../parser/receiver/receiver_statsd.go        |   2 +-
 .../parser/receiver/receiver_syslog.go        |  10 +-
 .../parser/receiver/receiver_syslog_test.go   |  10 +-
 .../parser/receiver/receiver_tcplog.go        |   4 +-
 .../parser/receiver/receiver_tcplog_test.go   |   8 +-
 .../parser/receiver/receiver_test.go          |  12 +-
 .../parser/receiver/receiver_udplog.go        |   4 +-
 .../parser/receiver/receiver_udplog_test.go   |   8 +-
 .../parser/receiver/receiver_wavefront.go     |   2 +-
 .../parser/receiver/receiver_zipkin-scribe.go |   2 +-
 .../parser/receiver/receiver_zipkin.go        |   2 +-
 internal/manifests/collector/podmonitor.go    |  13 +-
 internal/manifests/collector/rbac.go          |  23 +---
 internal/manifests/collector/service.go       |  14 +--
 .../manifests/collector/servicemonitor.go     |  14 +--
 52 files changed, 264 insertions(+), 430 deletions(-)
 create mode 100755 .chloggen/2603-part-two.yaml

diff --git a/.chloggen/2603-part-two.yaml b/.chloggen/2603-part-two.yaml
new file mode 100755
index 0000000000..2bd749cef7
--- /dev/null
+++ b/.chloggen/2603-part-two.yaml
@@ -0,0 +1,16 @@
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. collector, target allocator, auto-instrumentation, opamp, github action)
+component: collector
+
+# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Changes the internal behavior of port generation to use the new config structs
+
+# One or more tracking issues related to the change
+issues: [2603]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
diff --git a/internal/manifests/collector/adapters/config_to_ports.go b/internal/manifests/collector/adapters/config_to_ports.go
index 0a8b183d4f..f8f380ce00 100644
--- a/internal/manifests/collector/adapters/config_to_ports.go
+++ b/internal/manifests/collector/adapters/config_to_ports.go
@@ -15,7 +15,6 @@
 package adapters
 
 import (
-	"fmt"
 	"net"
 	"sort"
 	"strconv"
@@ -42,101 +41,59 @@ func (c ComponentType) String() string {
 	return [...]string{"receiver", "exporter", "processor"}[c]
 }
 
-// ConfigToComponentPorts converts the incoming configuration object into a set of service ports required by the exporters.
-func ConfigToComponentPorts(logger logr.Logger, cType ComponentType, config map[interface{}]interface{}) ([]v1beta1.PortsSpec, error) {
-	// now, we gather which ports we might need to open
-	// for that, we get all the exporters and check their `endpoint` properties,
-	// extracting the port from it. The port name has to be a "DNS_LABEL", so, we try to make it follow the pattern:
-	// ${instance.Name}-${exporter.name}-${exporter.qualifier}
-	// the exporter-name is typically the node name from the exporters map
-	// the exporter-qualifier is what comes after the slash in the exporter name, but typically nil
-	// examples:
-	// ```yaml
-	// components:
-	//   componentexample:
-	//     endpoint: 0.0.0.0:12345
-	//   componentexample/settings:
-	//     endpoint: 0.0.0.0:12346
-	// in this case, we have 2 ports, named: "componentexample" and "componentexample-settings"
-	componentsProperty, ok := config[fmt.Sprintf("%ss", cType.String())]
-	if !ok {
-		return nil, fmt.Errorf("no %ss available as part of the configuration", cType)
-	}
-
-	components, ok := componentsProperty.(map[interface{}]interface{})
-	if !ok {
-		return nil, fmt.Errorf("%ss doesn't contain valid components", cType.String())
-	}
-
-	compEnabled := getEnabledComponents(config, cType)
+func PortsForExporters(l logr.Logger, c v1beta1.Config) ([]v1beta1.PortsSpec, error) {
+	compEnabled := getEnabledComponents(c.Service, ComponentTypeExporter)
+	return componentPorts(l, c.Exporters, exporterParser.For, compEnabled)
+}
 
-	if compEnabled == nil {
-		return nil, fmt.Errorf("no enabled %ss available as part of the configuration", cType)
-	}
+func PortsForReceivers(l logr.Logger, c v1beta1.Config) ([]v1beta1.PortsSpec, error) {
+	compEnabled := getEnabledComponents(c.Service, ComponentTypeReceiver)
+	return componentPorts(l, c.Receivers, receiverParser.For, compEnabled)
+}
 
-	ports := []corev1.ServicePort{}
-	for key, val := range components {
-		// This check will pass only the enabled components,
-		// then only the related ports will be opened.
-		if !compEnabled[key] {
+func componentPorts(l logr.Logger, c v1beta1.AnyConfig, p parser.For, enabledComponents map[string]bool) ([]v1beta1.PortsSpec, error) {
+	var ports []corev1.ServicePort
+	for cmptName, val := range c.Object {
+		if !enabledComponents[cmptName] {
 			continue
 		}
-		exporter, ok := val.(map[interface{}]interface{})
+		component, ok := val.(map[string]interface{})
 		if !ok {
-			logger.V(2).Info("component doesn't seem to be a map of properties", cType.String(), key)
-			exporter = map[interface{}]interface{}{}
+			component = map[string]interface{}{}
 		}
-
-		cmptName := key.(string)
-		var cmptParser parser.ComponentPortParser
-		var err error
-		switch cType {
-		case ComponentTypeExporter:
-			cmptParser, err = exporterParser.For(logger, cmptName, exporter)
-		case ComponentTypeReceiver:
-			cmptParser, err = receiverParser.For(logger, cmptName, exporter)
-		case ComponentTypeProcessor:
-			logger.V(4).Info("processors don't provide a way to enable associated ports", "name", key)
-		}
-
+		componentParser, err := p(l, cmptName, component)
 		if err != nil {
-			logger.V(2).Info("no parser found for", "component", cmptName)
+			l.Error(err, "failed to retrieve parser for '%s', has returned an error: %w", cmptName, err)
 			continue
 		}
-
-		exprtPorts, err := cmptParser.Ports()
+		componentPorts, err := componentParser.Ports()
 		if err != nil {
-			logger.Error(err, "parser for '%s' has returned an error: %w", cmptName, err)
+			l.Error(err, "parser for '%s' has returned an error: %w", cmptName, err)
 			continue
 		}
-
-		if len(exprtPorts) > 0 {
-			ports = append(ports, exprtPorts...)
-		}
+		ports = append(ports, componentPorts...)
 	}
 
 	sort.Slice(ports, func(i, j int) bool {
 		return ports[i].Name < ports[j].Name
 	})
-
 	patchedPorts := []v1beta1.PortsSpec{}
 	for _, p := range ports {
 		patchedPorts = append(patchedPorts, v1beta1.PortsSpec{
 			ServicePort: p,
 		})
 	}
-
 	return patchedPorts, nil
 }
 
-func ConfigToPorts(logger logr.Logger, config map[interface{}]interface{}) ([]v1beta1.PortsSpec, error) {
-	ports, err := ConfigToComponentPorts(logger, ComponentTypeReceiver, config)
+func ConfigToPorts(logger logr.Logger, config v1beta1.Config) ([]v1beta1.PortsSpec, error) {
+	ports, err := PortsForReceivers(logger, config)
 	if err != nil {
 		logger.Error(err, "there was a problem while getting the ports from the receivers")
 		return nil, err
 	}
 
-	exporterPorts, err := ConfigToComponentPorts(logger, ComponentTypeExporter, config)
+	exporterPorts, err := PortsForExporters(logger, config)
 	if err != nil {
 		logger.Error(err, "there was a problem while getting the ports from the exporters")
 		return nil, err
diff --git a/internal/manifests/collector/adapters/config_to_ports_test.go b/internal/manifests/collector/adapters/config_to_ports_test.go
index 160d998487..c7eb6a802a 100644
--- a/internal/manifests/collector/adapters/config_to_ports_test.go
+++ b/internal/manifests/collector/adapters/config_to_ports_test.go
@@ -20,7 +20,7 @@ import (
 
 	"github.com/go-logr/logr"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
@@ -80,12 +80,13 @@ service:
 
 func TestExtractPortsFromConfig(t *testing.T) {
 	// prepare
-	config, err := adapters.ConfigFromString(portConfigStr)
-	require.NoError(t, err)
-	require.NotEmpty(t, config)
+	cfg := v1beta1.Config{}
+	if err := yaml.Unmarshal([]byte(portConfigStr), &cfg); err != nil {
+		t.Fatal(err)
+	}
 
 	// test
-	ports, err := adapters.ConfigToComponentPorts(logger, adapters.ComponentTypeReceiver, config)
+	ports, err := adapters.PortsForReceivers(logger, cfg)
 	assert.NoError(t, err)
 	assert.Len(t, ports, 10)
 
@@ -116,38 +117,6 @@ func TestExtractPortsFromConfig(t *testing.T) {
 	assert.ElementsMatch(t, expectedPorts, svcPorts)
 }
 
-func TestNoPortsParsed(t *testing.T) {
-	for _, tt := range []struct {
-		expected  error
-		desc      string
-		configStr string
-	}{
-		{
-			expected:  errors.New("no receivers available as part of the configuration"),
-			desc:      "empty",
-			configStr: "",
-		},
-		{
-			expected:  errors.New("receivers doesn't contain valid components"),
-			desc:      "not a map",
-			configStr: "receivers: some-string",
-		},
-	} {
-		t.Run(tt.desc, func(t *testing.T) {
-			// prepare
-			config, err := adapters.ConfigFromString(tt.configStr)
-			require.NoError(t, err)
-
-			// test
-			ports, err := adapters.ConfigToComponentPorts(logger, adapters.ComponentTypeReceiver, config)
-
-			// verify
-			assert.Nil(t, ports)
-			assert.Equal(t, tt.expected, err)
-		})
-	}
-}
-
 func TestInvalidReceivers(t *testing.T) {
 	for _, tt := range []struct {
 		desc      string
@@ -164,11 +133,12 @@ func TestInvalidReceivers(t *testing.T) {
 	} {
 		t.Run(tt.desc, func(t *testing.T) {
 			// prepare
-			config, err := adapters.ConfigFromString(tt.configStr)
-			require.NoError(t, err)
-
+			cfg := v1beta1.Config{}
+			if err := yaml.Unmarshal([]byte(tt.configStr), &cfg); err != nil {
+				t.Fatal(err)
+			}
 			// test
-			ports, err := adapters.ConfigToComponentPorts(logger, adapters.ComponentTypeReceiver, config)
+			ports, err := adapters.PortsForReceivers(logger, cfg)
 
 			// verify
 			assert.NoError(t, err)
@@ -186,25 +156,29 @@ func TestParserFailed(t *testing.T) {
 			return nil, errors.New("mocked error")
 		},
 	}
-	receiver.Register("mock", func(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+	receiver.Register("mock", func(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 		return mockParser
 	})
 
-	config := map[interface{}]interface{}{
-		"receivers": map[interface{}]interface{}{
-			"mock": map[string]interface{}{},
+	cfg := v1beta1.Config{
+		Receivers: v1beta1.AnyConfig{
+			Object: map[string]interface{}{
+				"mock": map[string]interface{}{},
+			},
 		},
-		"service": map[interface{}]interface{}{
-			"pipelines": map[interface{}]interface{}{
-				"metrics": map[interface{}]interface{}{
-					"receivers": []interface{}{"mock"},
+		Service: v1beta1.Service{
+			Pipelines: v1beta1.AnyConfig{
+				Object: map[string]interface{}{
+					"metrics": map[string]interface{}{
+						"receivers": []interface{}{"mock"},
+					},
 				},
 			},
 		},
 	}
 
 	// test
-	ports, err := adapters.ConfigToComponentPorts(logger, adapters.ComponentTypeReceiver, config)
+	ports, err := adapters.PortsForReceivers(logger, cfg)
 
 	// verify
 	assert.Len(t, ports, 0)
diff --git a/internal/manifests/collector/adapters/config_to_rbac.go b/internal/manifests/collector/adapters/config_to_rbac.go
index 55fd2d9bef..5fb1cdc2b0 100644
--- a/internal/manifests/collector/adapters/config_to_rbac.go
+++ b/internal/manifests/collector/adapters/config_to_rbac.go
@@ -18,38 +18,29 @@ import (
 	"github.com/go-logr/logr"
 	rbacv1 "k8s.io/api/rbac/v1"
 
+	"github.com/open-telemetry/opentelemetry-operator/apis/v1beta1"
 	"github.com/open-telemetry/opentelemetry-operator/internal/manifests/collector/parser/processor"
 )
 
 // ConfigToRBAC parses the OpenTelemetry Collector configuration and checks what RBAC resources are needed to be created.
-func ConfigToRBAC(logger logr.Logger, config map[interface{}]interface{}) []rbacv1.PolicyRule {
+func ConfigToRBAC(logger logr.Logger, config v1beta1.Config) []rbacv1.PolicyRule {
 	var policyRules []rbacv1.PolicyRule
-	processorsRaw, ok := config["processors"]
-	if !ok {
-		logger.V(2).Info("no processors available as part of the configuration")
+	if config.Processors == nil {
 		return policyRules
 	}
+	enabledProcessors := getEnabledComponents(config.Service, ComponentTypeProcessor)
 
-	processors, ok := processorsRaw.(map[interface{}]interface{})
-	if !ok {
-		logger.V(2).Info("processors doesn't contain valid components")
-		return policyRules
-	}
-
-	enabledProcessors := getEnabledComponents(config, ComponentTypeProcessor)
-
-	for key, val := range processors {
-		if !enabledProcessors[key] {
+	for processorName, val := range config.Processors.Object {
+		if !enabledProcessors[processorName] {
 			continue
 		}
 
-		processorCfg, ok := val.(map[interface{}]interface{})
+		processorCfg, ok := val.(map[string]interface{})
 		if !ok {
-			logger.V(2).Info("processor doesn't seem to be a map of properties", "processor", key)
-			processorCfg = map[interface{}]interface{}{}
+			logger.V(2).Info("processor doesn't seem to be a map of properties", "processor", processorName)
+			processorCfg = map[string]interface{}{}
 		}
 
-		processorName := key.(string)
 		processorParser, err := processor.For(logger, processorName, processorCfg)
 		if err != nil {
 			logger.V(2).Info("no parser found for", "processor", processorName)
diff --git a/internal/manifests/collector/adapters/config_to_rbac_test.go b/internal/manifests/collector/adapters/config_to_rbac_test.go
index 28774ca846..fb3ab46de4 100644
--- a/internal/manifests/collector/adapters/config_to_rbac_test.go
+++ b/internal/manifests/collector/adapters/config_to_rbac_test.go
@@ -19,8 +19,11 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
 	rbacv1 "k8s.io/api/rbac/v1"
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
+
+	"github.com/open-telemetry/opentelemetry-operator/apis/v1beta1"
 )
 
 func TestConfigRBAC(t *testing.T) {
@@ -87,12 +90,12 @@ service:
 
 	for _, tt := range tests {
 		t.Run(tt.desc, func(t *testing.T) {
-			config, err := ConfigFromString(tt.config)
-			require.NoError(t, err, tt.desc)
-			require.NotEmpty(t, config, tt.desc)
+			cfg := v1beta1.Config{}
+			err := yaml.Unmarshal([]byte(tt.config), &cfg)
+			require.NoError(t, err)
 
 			// test
-			rules := ConfigToRBAC(logger, config)
+			rules := ConfigToRBAC(logger, cfg)
 			assert.NoError(t, err)
 			assert.Equal(t, tt.expectedRules, rules, tt.desc)
 		})
diff --git a/internal/manifests/collector/adapters/config_validate.go b/internal/manifests/collector/adapters/config_validate.go
index ff0c86c9b8..8bcd20e026 100644
--- a/internal/manifests/collector/adapters/config_validate.go
+++ b/internal/manifests/collector/adapters/config_validate.go
@@ -14,92 +14,48 @@
 
 package adapters
 
-import "fmt"
+import (
+	"fmt"
+
+	"github.com/open-telemetry/opentelemetry-operator/apis/v1beta1"
+)
 
 // Following Otel Doc: Configuring a receiver does not enable it. The receivers are enabled via pipelines within the service section.
 // getEnabledComponents returns all enabled components as a true flag set. If it can't find any receiver, it will return a nil interface.
-func getEnabledComponents(config map[interface{}]interface{}, componentType ComponentType) map[interface{}]bool {
+func getEnabledComponents(config v1beta1.Service, componentType ComponentType) map[string]bool {
+	availableComponents := map[string]bool{}
 	componentTypePlural := fmt.Sprintf("%ss", componentType.String())
-	cfgComponents, ok := config[componentTypePlural]
-	if !ok {
-		return nil
-	}
-	components, ok := cfgComponents.(map[interface{}]interface{})
-	if !ok {
-		return nil
-	}
-	availableComponents := map[interface{}]bool{}
-
-	for compID := range components {
-
-		//Safe Cast
-		componentID, withComponent := compID.(string)
-		if !withComponent {
-			return nil
-		}
-		//Getting all components present in the components (exporters,receivers...) section and setting them to false.
-		availableComponents[componentID] = false
-	}
-
-	cfgService, withService := config["service"].(map[interface{}]interface{})
-	if !withService {
-		return nil
-	}
-
-	pipeline, withPipeline := cfgService["pipelines"].(map[interface{}]interface{})
-	if !withPipeline {
-		return nil
-	}
-	availablePipelines := map[string]bool{}
-
-	for pipID := range pipeline {
-		//Safe Cast
-		pipelineID, existsPipeline := pipID.(string)
-		if !existsPipeline {
-			return nil
-		}
-		//Getting all the available pipelines.
-		availablePipelines[pipelineID] = true
-	}
-
-	if len(pipeline) > 0 {
-		for pipelineID, pipelineCfg := range pipeline {
-			//Safe Cast
-			pipelineV, withPipelineCfg := pipelineID.(string)
-			if !withPipelineCfg {
-				continue
+	for pipelineID, pipelineCfg := range config.Pipelines.Object {
+		//Condition will get information if there are multiple configured pipelines.
+		if len(pipelineID) > 0 {
+			pipelineDesc, ok := pipelineCfg.(map[string]interface{})
+			if !ok {
+				return nil
 			}
-			//Condition will get information if there are multiple configured pipelines.
-			if len(pipelineV) > 0 {
-				pipelineDesc, ok := pipelineCfg.(map[interface{}]interface{})
-				if !ok {
-					return nil
-				}
-				for pipSpecID, pipSpecCfg := range pipelineDesc {
-					if pipSpecID.(string) == componentTypePlural {
-						receiversList, ok := pipSpecCfg.([]interface{})
-						if !ok {
-							continue
-						}
-						// If receiversList is empty means that we haven't any enabled Receiver.
-						if len(receiversList) == 0 {
-							availableComponents = nil
-						} else {
-							// All enabled receivers will be set as true
-							for _, comKey := range receiversList {
-								//Safe Cast
-								receiverKey, ok := comKey.(string)
-								if !ok {
-									return nil
-								}
-								availableComponents[receiverKey] = true
+			for pipSpecID, pipSpecCfg := range pipelineDesc {
+				if pipSpecID == componentTypePlural {
+					receiversList, ok := pipSpecCfg.([]interface{})
+					if !ok {
+						continue
+					}
+					// If receiversList is empty means that we haven't any enabled Receiver.
+					if len(receiversList) == 0 {
+						availableComponents = nil
+					} else {
+						// All enabled receivers will be set as true
+						for _, comKey := range receiversList {
+							//Safe Cast
+							receiverKey, ok := comKey.(string)
+							if !ok {
+								return nil
 							}
+							availableComponents[receiverKey] = true
 						}
-						//Removing all non-enabled receivers
-						for comID, comKey := range availableComponents {
-							if !(comKey) {
-								delete(availableComponents, comID)
-							}
+					}
+					//Removing all non-enabled receivers
+					for comID, comKey := range availableComponents {
+						if !(comKey) {
+							delete(availableComponents, comID)
 						}
 					}
 				}
diff --git a/internal/manifests/collector/adapters/config_validate_test.go b/internal/manifests/collector/adapters/config_validate_test.go
index 7003235fed..5689408930 100644
--- a/internal/manifests/collector/adapters/config_validate_test.go
+++ b/internal/manifests/collector/adapters/config_validate_test.go
@@ -18,6 +18,9 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
+
+	"github.com/open-telemetry/opentelemetry-operator/apis/v1beta1"
 )
 
 func TestConfigValidate(t *testing.T) {
@@ -52,12 +55,12 @@ service:
       exporters: [debug]
 `
 	// // prepare
-	config, err := ConfigFromString(configStr)
+	cfg := v1beta1.Config{}
+	err := yaml.Unmarshal([]byte(configStr), &cfg)
 	require.NoError(t, err)
-	require.NotEmpty(t, config)
 
 	// test
-	check := getEnabledComponents(config, ComponentTypeReceiver)
+	check := getEnabledComponents(cfg.Service, ComponentTypeReceiver)
 	require.NotEmpty(t, check)
 }
 
@@ -93,11 +96,11 @@ service:
       exporters: []
 `
 	// // prepare
-	config, err := ConfigFromString(configStr)
+	cfg := v1beta1.Config{}
+	err := yaml.Unmarshal([]byte(configStr), &cfg)
 	require.NoError(t, err)
-	require.NotEmpty(t, config)
 
 	// test
-	check := getEnabledComponents(config, ComponentTypeReceiver)
+	check := getEnabledComponents(cfg.Service, ComponentTypeReceiver)
 	require.Empty(t, check)
 }
diff --git a/internal/manifests/collector/container.go b/internal/manifests/collector/container.go
index 4f5c1b5ef6..e160881961 100644
--- a/internal/manifests/collector/container.go
+++ b/internal/manifests/collector/container.go
@@ -49,7 +49,7 @@ func Container(cfg config.Config, logger logr.Logger, otelcol v1beta1.OpenTeleme
 	}
 
 	// build container ports from service ports
-	ports, err := getConfigContainerPorts(logger, configYaml, otelcol.Spec.Config)
+	ports, err := getConfigContainerPorts(logger, otelcol.Spec.Config)
 	if err != nil {
 		logger.Error(err, "container ports config")
 	}
@@ -169,14 +169,9 @@ func Container(cfg config.Config, logger logr.Logger, otelcol v1beta1.OpenTeleme
 	}
 }
 
-func getConfigContainerPorts(logger logr.Logger, cfgYaml string, conf v1beta1.Config) (map[string]corev1.ContainerPort, error) {
+func getConfigContainerPorts(logger logr.Logger, conf v1beta1.Config) (map[string]corev1.ContainerPort, error) {
 	ports := map[string]corev1.ContainerPort{}
-	c, err := adapters.ConfigFromString(cfgYaml)
-	if err != nil {
-		logger.Error(err, "couldn't extract the configuration")
-		return ports, err
-	}
-	ps, err := adapters.ConfigToPorts(logger, c)
+	ps, err := adapters.ConfigToPorts(logger, conf)
 	if err != nil {
 		return ports, err
 	}
diff --git a/internal/manifests/collector/ingress.go b/internal/manifests/collector/ingress.go
index f8a7530d3d..16d26ef8df 100644
--- a/internal/manifests/collector/ingress.go
+++ b/internal/manifests/collector/ingress.go
@@ -136,17 +136,7 @@ func createSubdomainIngressRules(otelcol string, hostname string, ports []corev1
 }
 
 func servicePortsFromCfg(logger logr.Logger, otelcol v1beta1.OpenTelemetryCollector) ([]corev1.ServicePort, error) {
-	out, err := otelcol.Spec.Config.Yaml()
-	if err != nil {
-		return nil, err
-	}
-	configFromString, err := adapters.ConfigFromString(out)
-	if err != nil {
-		logger.Error(err, "couldn't extract the configuration from the context")
-		return nil, err
-	}
-
-	ports, err := adapters.ConfigToComponentPorts(logger, adapters.ComponentTypeReceiver, configFromString)
+	ports, err := adapters.PortsForReceivers(logger, otelcol.Spec.Config)
 	if err != nil {
 		logger.Error(err, "couldn't build the ingress for this instance")
 		return nil, err
diff --git a/internal/manifests/collector/parser/exporter/exporter.go b/internal/manifests/collector/parser/exporter/exporter.go
index 93c66b8599..80272d692b 100644
--- a/internal/manifests/collector/parser/exporter/exporter.go
+++ b/internal/manifests/collector/parser/exporter/exporter.go
@@ -38,7 +38,7 @@ func BuilderFor(name string) parser.Builder {
 }
 
 // For returns a new parser for the given exporter name + config.
-func For(logger logr.Logger, name string, config map[interface{}]interface{}) (parser.ComponentPortParser, error) {
+func For(logger logr.Logger, name string, config map[string]interface{}) (parser.ComponentPortParser, error) {
 	builder := BuilderFor(name)
 	if builder == nil {
 		return nil, fmt.Errorf("no builders for %s", name)
@@ -61,7 +61,7 @@ var (
 	endpointKey = "endpoint"
 )
 
-func singlePortFromConfigEndpoint(logger logr.Logger, name string, config map[interface{}]interface{}) *corev1.ServicePort {
+func singlePortFromConfigEndpoint(logger logr.Logger, name string, config map[string]interface{}) *corev1.ServicePort {
 	endpoint := getAddressFromConfig(logger, name, endpointKey, config)
 
 	switch e := endpoint.(type) {
@@ -85,7 +85,7 @@ func singlePortFromConfigEndpoint(logger logr.Logger, name string, config map[in
 	return nil
 }
 
-func getAddressFromConfig(logger logr.Logger, name, key string, config map[interface{}]interface{}) interface{} {
+func getAddressFromConfig(logger logr.Logger, name, key string, config map[string]interface{}) interface{} {
 	endpoint, ok := config[key]
 	if !ok {
 		logger.V(2).Info("%s exporter doesn't have an %s", name, key)
diff --git a/internal/manifests/collector/parser/exporter/exporter_prometheus.go b/internal/manifests/collector/parser/exporter/exporter_prometheus.go
index 30047de70e..e963d9887c 100644
--- a/internal/manifests/collector/parser/exporter/exporter_prometheus.go
+++ b/internal/manifests/collector/parser/exporter/exporter_prometheus.go
@@ -32,13 +32,13 @@ const (
 
 // PrometheusExporterParser parses the configuration for OTLP receivers.
 type PrometheusExporterParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewPrometheusExporterParser builds a new parser for OTLP receivers.
-func NewPrometheusExporterParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewPrometheusExporterParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &PrometheusExporterParser{
 		logger: logger,
 		name:   name,
diff --git a/internal/manifests/collector/parser/exporter/exporter_test.go b/internal/manifests/collector/parser/exporter/exporter_test.go
index bc468be110..2183bddec1 100644
--- a/internal/manifests/collector/parser/exporter/exporter_test.go
+++ b/internal/manifests/collector/parser/exporter/exporter_test.go
@@ -32,7 +32,7 @@ func TestPorts(t *testing.T) {
 			testName: "Valid Configuration",
 			parser: &PrometheusExporterParser{
 				name: "test-exporter",
-				config: map[interface{}]interface{}{
+				config: map[string]interface{}{
 					"endpoint": "http://myprometheus.io:9090",
 				},
 			},
@@ -62,7 +62,7 @@ func TestPorts(t *testing.T) {
 			testName: "Invalid Endpoint No Port",
 			parser: &PrometheusExporterParser{
 				name: "test-exporter",
-				config: map[interface{}]interface{}{
+				config: map[string]interface{}{
 					"endpoint": "invalidendpoint",
 				},
 			},
diff --git a/internal/manifests/collector/parser/parser.go b/internal/manifests/collector/parser/parser.go
index 62de283b15..1a0338b317 100644
--- a/internal/manifests/collector/parser/parser.go
+++ b/internal/manifests/collector/parser/parser.go
@@ -28,4 +28,7 @@ type ComponentPortParser interface {
 }
 
 // Builder specifies the signature required for parser builders.
-type Builder func(logr.Logger, string, map[interface{}]interface{}) ComponentPortParser
+type Builder func(logr.Logger, string, map[string]interface{}) ComponentPortParser
+
+// For returns the builder for the given name and a boolean if it was found successfully.
+type For func(logger logr.Logger, name string, config map[string]interface{}) (ComponentPortParser, error)
diff --git a/internal/manifests/collector/parser/processor/processor.go b/internal/manifests/collector/parser/processor/processor.go
index 784fffeade..ddc4f88526 100644
--- a/internal/manifests/collector/parser/processor/processor.go
+++ b/internal/manifests/collector/parser/processor/processor.go
@@ -30,7 +30,7 @@ type ProcessorParser interface {
 }
 
 // Builder specifies the signature required for parser builders.
-type Builder func(logr.Logger, string, map[interface{}]interface{}) ProcessorParser
+type Builder func(logr.Logger, string, map[string]interface{}) ProcessorParser
 
 // registry holds a record of all known processor parsers.
 var registry = make(map[string]Builder)
@@ -41,7 +41,7 @@ func BuilderFor(name string) Builder {
 }
 
 // For returns a new parser for the given processor name + config.
-func For(logger logr.Logger, name string, config map[interface{}]interface{}) (ProcessorParser, error) {
+func For(logger logr.Logger, name string, config map[string]interface{}) (ProcessorParser, error) {
 	builder := BuilderFor(name)
 	if builder == nil {
 		return nil, fmt.Errorf("no builders for %s", name)
diff --git a/internal/manifests/collector/parser/processor/processor_k8sattributes.go b/internal/manifests/collector/parser/processor/processor_k8sattributes.go
index 293411acbf..f254fa1f36 100644
--- a/internal/manifests/collector/parser/processor/processor_k8sattributes.go
+++ b/internal/manifests/collector/parser/processor/processor_k8sattributes.go
@@ -30,13 +30,13 @@ const (
 
 // PrometheusExporterParser parses the configuration for k8sattributes processor.
 type K8sAttributesParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewK8sAttributesParser builds a new parser k8sattributes processor.
-func NewK8sAttributesParser(logger logr.Logger, name string, config map[interface{}]interface{}) ProcessorParser {
+func NewK8sAttributesParser(logger logr.Logger, name string, config map[string]interface{}) ProcessorParser {
 	return &K8sAttributesParser{
 		logger: logger,
 		name:   name,
@@ -69,7 +69,7 @@ func (o *K8sAttributesParser) GetRBACRules() []rbacv1.PolicyRule {
 		return prs
 	}
 
-	metadataCfg, ok := extractCfg.(map[interface{}]interface{})["metadata"]
+	metadataCfg, ok := extractCfg.(map[string]interface{})["metadata"]
 	if !ok {
 		return prs
 	}
diff --git a/internal/manifests/collector/parser/processor/processor_k8sattributes_test.go b/internal/manifests/collector/parser/processor/processor_k8sattributes_test.go
index c6328cc51f..d8fc29c91e 100644
--- a/internal/manifests/collector/parser/processor/processor_k8sattributes_test.go
+++ b/internal/manifests/collector/parser/processor/processor_k8sattributes_test.go
@@ -28,7 +28,7 @@ func TestK8sAttributesRBAC(t *testing.T) {
 
 	tests := []struct {
 		name          string
-		config        map[interface{}]interface{}
+		config        map[string]interface{}
 		expectedRules []rbacv1.PolicyRule
 	}{
 		{
@@ -49,8 +49,8 @@ func TestK8sAttributesRBAC(t *testing.T) {
 		},
 		{
 			name: "extract k8s.node",
-			config: map[interface{}]interface{}{
-				"extract": map[interface{}]interface{}{
+			config: map[string]interface{}{
+				"extract": map[string]interface{}{
 					"metadata": []interface{}{
 						"k8s.node",
 					},
diff --git a/internal/manifests/collector/parser/processor/processor_resourcedetection.go b/internal/manifests/collector/parser/processor/processor_resourcedetection.go
index b9038733c5..23c4a34ff0 100644
--- a/internal/manifests/collector/parser/processor/processor_resourcedetection.go
+++ b/internal/manifests/collector/parser/processor/processor_resourcedetection.go
@@ -29,13 +29,13 @@ const (
 
 // PrometheusExporterParser parses the configuration for OTLP receivers.
 type ResourceDetectionParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewPrometheusExporterParser builds a new parser for OTLP receivers.
-func NewResourceDetectionParser(logger logr.Logger, name string, config map[interface{}]interface{}) ProcessorParser {
+func NewResourceDetectionParser(logger logr.Logger, name string, config map[string]interface{}) ProcessorParser {
 	return &ResourceDetectionParser{
 		logger: logger,
 		name:   name,
diff --git a/internal/manifests/collector/parser/receiver/receiver.go b/internal/manifests/collector/parser/receiver/receiver.go
index 127891747b..bb4909f915 100644
--- a/internal/manifests/collector/parser/receiver/receiver.go
+++ b/internal/manifests/collector/parser/receiver/receiver.go
@@ -44,7 +44,7 @@ func BuilderFor(name string) parser.Builder {
 }
 
 // For returns a new parser for the given receiver name + config.
-func For(logger logr.Logger, name string, config map[interface{}]interface{}) (parser.ComponentPortParser, error) {
+func For(logger logr.Logger, name string, config map[string]interface{}) (parser.ComponentPortParser, error) {
 	builder := BuilderFor(name)
 	return builder(logger, name, config), nil
 }
@@ -102,7 +102,7 @@ func isScraperReceiver(name string) bool {
 	return exists
 }
 
-func singlePortFromConfigEndpoint(logger logr.Logger, name string, config map[interface{}]interface{}) *v1.ServicePort {
+func singlePortFromConfigEndpoint(logger logr.Logger, name string, config map[string]interface{}) *v1.ServicePort {
 	var endpoint interface{}
 	var receiverType = receiverType(name)
 	switch {
@@ -137,7 +137,7 @@ func singlePortFromConfigEndpoint(logger logr.Logger, name string, config map[in
 	return nil
 }
 
-func getAddressFromConfig(logger logr.Logger, name, key string, config map[interface{}]interface{}) interface{} {
+func getAddressFromConfig(logger logr.Logger, name, key string, config map[string]interface{}) interface{} {
 	endpoint, ok := config[key]
 	if !ok {
 		logger.V(2).Info("%s receiver doesn't have an %s", name, key)
diff --git a/internal/manifests/collector/parser/receiver/receiver_aws-xray.go b/internal/manifests/collector/parser/receiver/receiver_aws-xray.go
index 44618b3aa5..e7911d0de3 100644
--- a/internal/manifests/collector/parser/receiver/receiver_aws-xray.go
+++ b/internal/manifests/collector/parser/receiver/receiver_aws-xray.go
@@ -23,7 +23,7 @@ import (
 const parserNameAWSXRAY = "__awsxray"
 
 // NewAWSXrayReceiverParser builds a new parser for AWS xray receivers, from the contrib repository.
-func NewAWSXrayReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewAWSXrayReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_carbon.go b/internal/manifests/collector/parser/receiver/receiver_carbon.go
index b1b0aaa4ce..55b6e705c2 100644
--- a/internal/manifests/collector/parser/receiver/receiver_carbon.go
+++ b/internal/manifests/collector/parser/receiver/receiver_carbon.go
@@ -23,7 +23,7 @@ import (
 const parserNameCarbon = "__carbon"
 
 // NewCarbonReceiverParser builds a new parser for Carbon receivers, from the contrib repository.
-func NewCarbonReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewCarbonReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_collectd.go b/internal/manifests/collector/parser/receiver/receiver_collectd.go
index aa42ab0397..436357ad89 100644
--- a/internal/manifests/collector/parser/receiver/receiver_collectd.go
+++ b/internal/manifests/collector/parser/receiver/receiver_collectd.go
@@ -23,7 +23,7 @@ import (
 const parserNameCollectd = "__collectd"
 
 // NewCollectdReceiverParser builds a new parser for Collectd receivers, from the contrib repository.
-func NewCollectdReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewCollectdReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_fluent-forward.go b/internal/manifests/collector/parser/receiver/receiver_fluent-forward.go
index 88881923fa..cd3596499f 100644
--- a/internal/manifests/collector/parser/receiver/receiver_fluent-forward.go
+++ b/internal/manifests/collector/parser/receiver/receiver_fluent-forward.go
@@ -23,7 +23,7 @@ import (
 const parserNameFluentForward = "__fluentforward"
 
 // NewFluentForwardReceiverParser builds a new parser for FluentForward receivers, from the contrib repository.
-func NewFluentForwardReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewFluentForwardReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_generic.go b/internal/manifests/collector/parser/receiver/receiver_generic.go
index 864b5bb111..1c7e314af2 100644
--- a/internal/manifests/collector/parser/receiver/receiver_generic.go
+++ b/internal/manifests/collector/parser/receiver/receiver_generic.go
@@ -28,7 +28,7 @@ var _ parser.ComponentPortParser = &GenericReceiver{}
 
 // GenericReceiver is a special parser for generic receivers. It doesn't self-register and should be created/used directly.
 type GenericReceiver struct {
-	config             map[interface{}]interface{}
+	config             map[string]interface{}
 	defaultAppProtocol *string
 	logger             logr.Logger
 	name               string
@@ -41,7 +41,7 @@ type GenericReceiver struct {
 // so that it can expose the required port based on the receiver's config. Receiver scrapers are ignored.
 
 // NewGenericReceiverParser builds a new parser for generic receivers.
-func NewGenericReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewGenericReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:     logger,
 		name:       name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_generic_test.go b/internal/manifests/collector/parser/receiver/receiver_generic_test.go
index 1adfcf12df..2e0a1299ba 100644
--- a/internal/manifests/collector/parser/receiver/receiver_generic_test.go
+++ b/internal/manifests/collector/parser/receiver/receiver_generic_test.go
@@ -30,7 +30,7 @@ var logger = logf.Log.WithName("unit-tests")
 func TestParseEndpoint(t *testing.T) {
 	// prepare
 	// there's no parser registered to handle "myreceiver", so, it falls back to the generic parser
-	builder := receiver.NewGenericReceiverParser(logger, "myreceiver", map[interface{}]interface{}{
+	builder := receiver.NewGenericReceiverParser(logger, "myreceiver", map[string]interface{}{
 		"endpoint": "0.0.0.0:1234",
 	})
 
@@ -46,7 +46,7 @@ func TestParseEndpoint(t *testing.T) {
 func TestFailedToParseEndpoint(t *testing.T) {
 	// prepare
 	// there's no parser registered to handle "myreceiver", so, it falls back to the generic parser
-	builder := receiver.NewGenericReceiverParser(logger, "myreceiver", map[interface{}]interface{}{
+	builder := receiver.NewGenericReceiverParser(logger, "myreceiver", map[string]interface{}{
 		"endpoint": "0.0.0.0",
 	})
 
@@ -60,7 +60,7 @@ func TestFailedToParseEndpoint(t *testing.T) {
 
 func TestDownstreamParsers(t *testing.T) {
 	for _, tt := range []struct {
-		builder      func(logr.Logger, string, map[interface{}]interface{}) parser.ComponentPortParser
+		builder      func(logr.Logger, string, map[string]interface{}) parser.ComponentPortParser
 		desc         string
 		receiverName string
 		parserName   string
@@ -85,7 +85,7 @@ func TestDownstreamParsers(t *testing.T) {
 		t.Run(tt.receiverName, func(t *testing.T) {
 			t.Run("builds successfully", func(t *testing.T) {
 				// test
-				builder := tt.builder(logger, tt.receiverName, map[interface{}]interface{}{})
+				builder := tt.builder(logger, tt.receiverName, map[string]interface{}{})
 
 				// verify
 				assert.Equal(t, tt.parserName, builder.ParserName())
@@ -93,7 +93,7 @@ func TestDownstreamParsers(t *testing.T) {
 
 			t.Run("assigns the expected port", func(t *testing.T) {
 				// prepare
-				builder := tt.builder(logger, tt.receiverName, map[interface{}]interface{}{})
+				builder := tt.builder(logger, tt.receiverName, map[string]interface{}{})
 
 				// test
 				ports, err := builder.Ports()
@@ -107,7 +107,7 @@ func TestDownstreamParsers(t *testing.T) {
 
 			t.Run("allows port to be overridden", func(t *testing.T) {
 				// prepare
-				builder := tt.builder(logger, tt.receiverName, map[interface{}]interface{}{
+				builder := tt.builder(logger, tt.receiverName, map[string]interface{}{
 					"endpoint": "0.0.0.0:65535",
 				})
 
diff --git a/internal/manifests/collector/parser/receiver/receiver_influxdb.go b/internal/manifests/collector/parser/receiver/receiver_influxdb.go
index 0930a29f73..736c27755f 100644
--- a/internal/manifests/collector/parser/receiver/receiver_influxdb.go
+++ b/internal/manifests/collector/parser/receiver/receiver_influxdb.go
@@ -23,7 +23,7 @@ import (
 const parserNameInfluxdb = "__influxdb"
 
 // NewInfluxdbReceiverParser builds a new parser for Influxdb receivers, from the contrib repository.
-func NewInfluxdbReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewInfluxdbReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_jaeger.go b/internal/manifests/collector/parser/receiver/receiver_jaeger.go
index dcc99d8bd9..2970640eec 100644
--- a/internal/manifests/collector/parser/receiver/receiver_jaeger.go
+++ b/internal/manifests/collector/parser/receiver/receiver_jaeger.go
@@ -37,14 +37,14 @@ const (
 
 // JaegerReceiverParser parses the configuration for Jaeger-specific receivers.
 type JaegerReceiverParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewJaegerReceiverParser builds a new parser for Jaeger receivers.
-func NewJaegerReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
-	if protocols, ok := config["protocols"].(map[interface{}]interface{}); ok {
+func NewJaegerReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
+	if protocols, ok := config["protocols"].(map[string]interface{}); ok {
 		return &JaegerReceiverParser{
 			logger: logger,
 			name:   name,
@@ -54,7 +54,7 @@ func NewJaegerReceiverParser(logger logr.Logger, name string, config map[interfa
 
 	return &JaegerReceiverParser{
 		name:   name,
-		config: map[interface{}]interface{}{},
+		config: map[string]interface{}{},
 	}
 }
 
@@ -98,7 +98,7 @@ func (j *JaegerReceiverParser) Ports() ([]corev1.ServicePort, error) {
 			var protocolPort *corev1.ServicePort
 
 			// do we have a configuration block for the protocol?
-			settings, ok := receiverProtocol.(map[interface{}]interface{})
+			settings, ok := receiverProtocol.(map[string]interface{})
 			if ok {
 				protocolPort = singlePortFromConfigEndpoint(j.logger, nameWithProtocol, settings)
 			}
diff --git a/internal/manifests/collector/parser/receiver/receiver_jaeger_test.go b/internal/manifests/collector/parser/receiver/receiver_jaeger_test.go
index dadf3e0cb5..1409eaa084 100644
--- a/internal/manifests/collector/parser/receiver/receiver_jaeger_test.go
+++ b/internal/manifests/collector/parser/receiver/receiver_jaeger_test.go
@@ -28,7 +28,7 @@ func TestJaegerSelfRegisters(t *testing.T) {
 
 func TestJaegerIsFoundByName(t *testing.T) {
 	// test
-	p, err := For(logger, "jaeger", map[interface{}]interface{}{})
+	p, err := For(logger, "jaeger", map[string]interface{}{})
 	assert.NoError(t, err)
 
 	// verify
@@ -37,9 +37,9 @@ func TestJaegerIsFoundByName(t *testing.T) {
 
 func TestJaegerMinimalConfiguration(t *testing.T) {
 	// prepare
-	builder := NewJaegerReceiverParser(logger, "jaeger", map[interface{}]interface{}{
-		"protocols": map[interface{}]interface{}{
-			"grpc": map[interface{}]interface{}{},
+	builder := NewJaegerReceiverParser(logger, "jaeger", map[string]interface{}{
+		"protocols": map[string]interface{}{
+			"grpc": map[string]interface{}{},
 		},
 	})
 
@@ -55,9 +55,9 @@ func TestJaegerMinimalConfiguration(t *testing.T) {
 
 func TestJaegerPortsOverridden(t *testing.T) {
 	// prepare
-	builder := NewJaegerReceiverParser(logger, "jaeger", map[interface{}]interface{}{
-		"protocols": map[interface{}]interface{}{
-			"grpc": map[interface{}]interface{}{
+	builder := NewJaegerReceiverParser(logger, "jaeger", map[string]interface{}{
+		"protocols": map[string]interface{}{
+			"grpc": map[string]interface{}{
 				"endpoint": "0.0.0.0:1234",
 			},
 		},
@@ -75,12 +75,12 @@ func TestJaegerPortsOverridden(t *testing.T) {
 
 func TestJaegerExposeDefaultPorts(t *testing.T) {
 	// prepare
-	builder := NewJaegerReceiverParser(logger, "jaeger", map[interface{}]interface{}{
-		"protocols": map[interface{}]interface{}{
-			"grpc":           map[interface{}]interface{}{},
-			"thrift_http":    map[interface{}]interface{}{},
-			"thrift_compact": map[interface{}]interface{}{},
-			"thrift_binary":  map[interface{}]interface{}{},
+	builder := NewJaegerReceiverParser(logger, "jaeger", map[string]interface{}{
+		"protocols": map[string]interface{}{
+			"grpc":           map[string]interface{}{},
+			"thrift_http":    map[string]interface{}{},
+			"thrift_compact": map[string]interface{}{},
+			"thrift_binary":  map[string]interface{}{},
 		},
 	})
 
diff --git a/internal/manifests/collector/parser/receiver/receiver_loki.go b/internal/manifests/collector/parser/receiver/receiver_loki.go
index 6cdac81356..5c81b99592 100644
--- a/internal/manifests/collector/parser/receiver/receiver_loki.go
+++ b/internal/manifests/collector/parser/receiver/receiver_loki.go
@@ -36,14 +36,14 @@ const (
 
 // LokiReceiverParser parses the configuration for Loki receivers.
 type LokiReceiverParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewLokiReceiverParser builds a new parser for Loki receivers.
-func NewLokiReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
-	if protocols, ok := config["protocols"].(map[interface{}]interface{}); ok {
+func NewLokiReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
+	if protocols, ok := config["protocols"].(map[string]interface{}); ok {
 		return &LokiReceiverParser{
 			logger: logger,
 			name:   name,
@@ -53,7 +53,7 @@ func NewLokiReceiverParser(logger logr.Logger, name string, config map[interface
 
 	return &LokiReceiverParser{
 		name:   name,
-		config: map[interface{}]interface{}{},
+		config: map[string]interface{}{},
 	}
 }
 
@@ -95,7 +95,7 @@ func (o *LokiReceiverParser) Ports() ([]corev1.ServicePort, error) {
 			var protocolPort *corev1.ServicePort
 
 			// do we have a configuration block for the protocol?
-			settings, ok := receiverProtocol.(map[interface{}]interface{})
+			settings, ok := receiverProtocol.(map[string]interface{})
 			if ok {
 				protocolPort = singlePortFromConfigEndpoint(o.logger, nameWithProtocol, settings)
 			}
diff --git a/internal/manifests/collector/parser/receiver/receiver_loki_test.go b/internal/manifests/collector/parser/receiver/receiver_loki_test.go
index cc10edc9f1..769978fb08 100644
--- a/internal/manifests/collector/parser/receiver/receiver_loki_test.go
+++ b/internal/manifests/collector/parser/receiver/receiver_loki_test.go
@@ -27,7 +27,7 @@ func TestLokiSelfRegisters(t *testing.T) {
 
 func TestLokiIsFoundByName(t *testing.T) {
 	// test
-	p, err := For(logger, "loki", map[interface{}]interface{}{})
+	p, err := For(logger, "loki", map[string]interface{}{})
 	assert.NoError(t, err)
 
 	// verify
@@ -36,12 +36,12 @@ func TestLokiIsFoundByName(t *testing.T) {
 
 func TestLokiPortsOverridden(t *testing.T) {
 	// prepare
-	builder := NewLokiReceiverParser(logger, "loki", map[interface{}]interface{}{
-		"protocols": map[interface{}]interface{}{
-			"grpc": map[interface{}]interface{}{
+	builder := NewLokiReceiverParser(logger, "loki", map[string]interface{}{
+		"protocols": map[string]interface{}{
+			"grpc": map[string]interface{}{
 				"endpoint": "0.0.0.0:1234",
 			},
-			"http": map[interface{}]interface{}{
+			"http": map[string]interface{}{
 				"endpoint": "0.0.0.0:1235",
 			},
 		},
@@ -75,10 +75,10 @@ func TestLokiPortsOverridden(t *testing.T) {
 
 func TestLokiExposeDefaultPorts(t *testing.T) {
 	// prepare
-	builder := NewLokiReceiverParser(logger, "loki", map[interface{}]interface{}{
-		"protocols": map[interface{}]interface{}{
-			"grpc": map[interface{}]interface{}{},
-			"http": map[interface{}]interface{}{},
+	builder := NewLokiReceiverParser(logger, "loki", map[string]interface{}{
+		"protocols": map[string]interface{}{
+			"grpc": map[string]interface{}{},
+			"http": map[string]interface{}{},
 		},
 	})
 
diff --git a/internal/manifests/collector/parser/receiver/receiver_oc.go b/internal/manifests/collector/parser/receiver/receiver_oc.go
index 6619439a82..8e5c050fa8 100644
--- a/internal/manifests/collector/parser/receiver/receiver_oc.go
+++ b/internal/manifests/collector/parser/receiver/receiver_oc.go
@@ -23,7 +23,7 @@ import (
 const parserNameOpenCensus = "__opencensus"
 
 // NewOpenCensusReceiverParser builds a new parser for OpenCensus receivers.
-func NewOpenCensusReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewOpenCensusReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	httpAppProtocol := "http"
 	return &GenericReceiver{
 		logger:             logger,
diff --git a/internal/manifests/collector/parser/receiver/receiver_otlp.go b/internal/manifests/collector/parser/receiver/receiver_otlp.go
index 68972fd950..6b07dd61ea 100644
--- a/internal/manifests/collector/parser/receiver/receiver_otlp.go
+++ b/internal/manifests/collector/parser/receiver/receiver_otlp.go
@@ -41,14 +41,14 @@ var (
 
 // OTLPReceiverParser parses the configuration for OTLP receivers.
 type OTLPReceiverParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewOTLPReceiverParser builds a new parser for OTLP receivers.
-func NewOTLPReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
-	if protocols, ok := config["protocols"].(map[interface{}]interface{}); ok {
+func NewOTLPReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
+	if protocols, ok := config["protocols"].(map[string]interface{}); ok {
 		return &OTLPReceiverParser{
 			logger: logger,
 			name:   name,
@@ -58,7 +58,7 @@ func NewOTLPReceiverParser(logger logr.Logger, name string, config map[interface
 
 	return &OTLPReceiverParser{
 		name:   name,
-		config: map[interface{}]interface{}{},
+		config: map[string]interface{}{},
 	}
 }
 
@@ -100,7 +100,7 @@ func (o *OTLPReceiverParser) Ports() ([]corev1.ServicePort, error) {
 			var protocolPort *corev1.ServicePort
 
 			// do we have a configuration block for the protocol?
-			settings, ok := receiverProtocol.(map[interface{}]interface{})
+			settings, ok := receiverProtocol.(map[string]interface{})
 			if ok {
 				protocolPort = singlePortFromConfigEndpoint(o.logger, nameWithProtocol, settings)
 			}
diff --git a/internal/manifests/collector/parser/receiver/receiver_otlp_test.go b/internal/manifests/collector/parser/receiver/receiver_otlp_test.go
index 7165153dde..099c6da267 100644
--- a/internal/manifests/collector/parser/receiver/receiver_otlp_test.go
+++ b/internal/manifests/collector/parser/receiver/receiver_otlp_test.go
@@ -27,7 +27,7 @@ func TestOTLPSelfRegisters(t *testing.T) {
 
 func TestOTLPIsFoundByName(t *testing.T) {
 	// test
-	p, err := For(logger, "otlp", map[interface{}]interface{}{})
+	p, err := For(logger, "otlp", map[string]interface{}{})
 	assert.NoError(t, err)
 
 	// verify
@@ -36,12 +36,12 @@ func TestOTLPIsFoundByName(t *testing.T) {
 
 func TestOTLPPortsOverridden(t *testing.T) {
 	// prepare
-	builder := NewOTLPReceiverParser(logger, "otlp", map[interface{}]interface{}{
-		"protocols": map[interface{}]interface{}{
-			"grpc": map[interface{}]interface{}{
+	builder := NewOTLPReceiverParser(logger, "otlp", map[string]interface{}{
+		"protocols": map[string]interface{}{
+			"grpc": map[string]interface{}{
 				"endpoint": "0.0.0.0:1234",
 			},
-			"http": map[interface{}]interface{}{
+			"http": map[string]interface{}{
 				"endpoint": "0.0.0.0:1235",
 			},
 		},
@@ -75,10 +75,10 @@ func TestOTLPPortsOverridden(t *testing.T) {
 
 func TestOTLPExposeDefaultPorts(t *testing.T) {
 	// prepare
-	builder := NewOTLPReceiverParser(logger, "otlp", map[interface{}]interface{}{
-		"protocols": map[interface{}]interface{}{
-			"grpc": map[interface{}]interface{}{},
-			"http": map[interface{}]interface{}{},
+	builder := NewOTLPReceiverParser(logger, "otlp", map[string]interface{}{
+		"protocols": map[string]interface{}{
+			"grpc": map[string]interface{}{},
+			"http": map[string]interface{}{},
 		},
 	})
 
diff --git a/internal/manifests/collector/parser/receiver/receiver_sapm.go b/internal/manifests/collector/parser/receiver/receiver_sapm.go
index 924b88bff5..a4e375be95 100644
--- a/internal/manifests/collector/parser/receiver/receiver_sapm.go
+++ b/internal/manifests/collector/parser/receiver/receiver_sapm.go
@@ -23,7 +23,7 @@ import (
 const parserNameSAPM = "__sapm"
 
 // NewSAPMReceiverParser builds a new parser for SAPM receivers, from the contrib repository.
-func NewSAPMReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewSAPMReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_signalfx.go b/internal/manifests/collector/parser/receiver/receiver_signalfx.go
index 549e802453..ce7ab3d107 100644
--- a/internal/manifests/collector/parser/receiver/receiver_signalfx.go
+++ b/internal/manifests/collector/parser/receiver/receiver_signalfx.go
@@ -23,7 +23,7 @@ import (
 const parserNameSignalFx = "__signalfx"
 
 // NewSignalFxReceiverParser builds a new parser for SignalFx receivers, from the contrib repository.
-func NewSignalFxReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewSignalFxReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_skywalking.go b/internal/manifests/collector/parser/receiver/receiver_skywalking.go
index 9b72847ee9..66d6ea7ec7 100644
--- a/internal/manifests/collector/parser/receiver/receiver_skywalking.go
+++ b/internal/manifests/collector/parser/receiver/receiver_skywalking.go
@@ -36,14 +36,14 @@ const (
 
 // SkywalkingReceiverParser parses the configuration for Skywalking receivers.
 type SkywalkingReceiverParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewSkywalkingReceiverParser builds a new parser for Skywalking receivers.
-func NewSkywalkingReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
-	if protocols, ok := config["protocols"].(map[interface{}]interface{}); ok {
+func NewSkywalkingReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
+	if protocols, ok := config["protocols"].(map[string]interface{}); ok {
 		return &SkywalkingReceiverParser{
 			logger: logger,
 			name:   name,
@@ -53,7 +53,7 @@ func NewSkywalkingReceiverParser(logger logr.Logger, name string, config map[int
 
 	return &SkywalkingReceiverParser{
 		name:   name,
-		config: map[interface{}]interface{}{},
+		config: map[string]interface{}{},
 	}
 }
 
@@ -95,7 +95,7 @@ func (o *SkywalkingReceiverParser) Ports() ([]corev1.ServicePort, error) {
 			var protocolPort *corev1.ServicePort
 
 			// do we have a configuration block for the protocol?
-			settings, ok := receiverProtocol.(map[interface{}]interface{})
+			settings, ok := receiverProtocol.(map[string]interface{})
 			if ok {
 				protocolPort = singlePortFromConfigEndpoint(o.logger, nameWithProtocol, settings)
 			}
diff --git a/internal/manifests/collector/parser/receiver/receiver_skywalking_test.go b/internal/manifests/collector/parser/receiver/receiver_skywalking_test.go
index ab00c852c2..160d76fc9d 100644
--- a/internal/manifests/collector/parser/receiver/receiver_skywalking_test.go
+++ b/internal/manifests/collector/parser/receiver/receiver_skywalking_test.go
@@ -27,7 +27,7 @@ func TestSkywalkingSelfRegisters(t *testing.T) {
 
 func TestSkywalkingIsFoundByName(t *testing.T) {
 	// test
-	p, err := For(logger, "skywalking", map[interface{}]interface{}{})
+	p, err := For(logger, "skywalking", map[string]interface{}{})
 	assert.NoError(t, err)
 
 	// verify
@@ -36,12 +36,12 @@ func TestSkywalkingIsFoundByName(t *testing.T) {
 
 func TestSkywalkingPortsOverridden(t *testing.T) {
 	// prepare
-	builder := NewSkywalkingReceiverParser(logger, "skywalking", map[interface{}]interface{}{
-		"protocols": map[interface{}]interface{}{
-			"grpc": map[interface{}]interface{}{
+	builder := NewSkywalkingReceiverParser(logger, "skywalking", map[string]interface{}{
+		"protocols": map[string]interface{}{
+			"grpc": map[string]interface{}{
 				"endpoint": "0.0.0.0:1234",
 			},
-			"http": map[interface{}]interface{}{
+			"http": map[string]interface{}{
 				"endpoint": "0.0.0.0:1235",
 			},
 		},
@@ -75,10 +75,10 @@ func TestSkywalkingPortsOverridden(t *testing.T) {
 
 func TestSkywalkingExposeDefaultPorts(t *testing.T) {
 	// prepare
-	builder := NewSkywalkingReceiverParser(logger, "skywalking", map[interface{}]interface{}{
-		"protocols": map[interface{}]interface{}{
-			"grpc": map[interface{}]interface{}{},
-			"http": map[interface{}]interface{}{},
+	builder := NewSkywalkingReceiverParser(logger, "skywalking", map[string]interface{}{
+		"protocols": map[string]interface{}{
+			"grpc": map[string]interface{}{},
+			"http": map[string]interface{}{},
 		},
 	})
 
diff --git a/internal/manifests/collector/parser/receiver/receiver_splunk-hec.go b/internal/manifests/collector/parser/receiver/receiver_splunk-hec.go
index 676415334b..38a7b548ce 100644
--- a/internal/manifests/collector/parser/receiver/receiver_splunk-hec.go
+++ b/internal/manifests/collector/parser/receiver/receiver_splunk-hec.go
@@ -23,7 +23,7 @@ import (
 const parserNameSplunkHec = "__splunk_hec"
 
 // NewSplunkHecReceiverParser builds a new parser for Splunk Hec receivers, from the contrib repository.
-func NewSplunkHecReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewSplunkHecReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_statsd.go b/internal/manifests/collector/parser/receiver/receiver_statsd.go
index 0f41520e22..c85818bfc4 100644
--- a/internal/manifests/collector/parser/receiver/receiver_statsd.go
+++ b/internal/manifests/collector/parser/receiver/receiver_statsd.go
@@ -24,7 +24,7 @@ import (
 const parserNameStatsd = "__statsd"
 
 // NewStatsdReceiverParser builds a new parser for Statsd receivers, from the contrib repository.
-func NewStatsdReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewStatsdReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:          logger,
 		name:            name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_syslog.go b/internal/manifests/collector/parser/receiver/receiver_syslog.go
index 582cb5c2be..5745526717 100644
--- a/internal/manifests/collector/parser/receiver/receiver_syslog.go
+++ b/internal/manifests/collector/parser/receiver/receiver_syslog.go
@@ -30,13 +30,13 @@ const parserNameSyslog = "__syslog"
 
 // SyslogReceiverParser parses the configuration for TCP log receivers.
 type SyslogReceiverParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewSyslogReceiverParser builds a new parser for TCP log receivers.
-func NewSyslogReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewSyslogReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &SyslogReceiverParser{
 		logger: logger,
 		name:   name,
@@ -48,19 +48,19 @@ func (o *SyslogReceiverParser) Ports() ([]corev1.ServicePort, error) {
 	var endpoint interface{}
 	var endpointName string
 	var protocol corev1.Protocol
-	var c map[interface{}]interface{}
+	var c map[string]interface{}
 
 	// syslog receiver contains the endpoint
 	// that needs to be exposed one level down inside config
 	// i.e. either in tcp or udp section with field key
 	// as `listen_address`
 	if tcp, isTCP := o.config["tcp"]; isTCP && tcp != nil {
-		c = tcp.(map[interface{}]interface{})
+		c = tcp.(map[string]interface{})
 		endpointName = "tcp"
 		endpoint = getAddressFromConfig(o.logger, o.name, listenAddressKey, c)
 		protocol = corev1.ProtocolTCP
 	} else if udp, isUDP := o.config["udp"]; isUDP && udp != nil {
-		c = udp.(map[interface{}]interface{})
+		c = udp.(map[string]interface{})
 		endpointName = "udp"
 		endpoint = getAddressFromConfig(o.logger, o.name, listenAddressKey, c)
 		protocol = corev1.ProtocolUDP
diff --git a/internal/manifests/collector/parser/receiver/receiver_syslog_test.go b/internal/manifests/collector/parser/receiver/receiver_syslog_test.go
index fd7ea9daf5..2d2f534d91 100644
--- a/internal/manifests/collector/parser/receiver/receiver_syslog_test.go
+++ b/internal/manifests/collector/parser/receiver/receiver_syslog_test.go
@@ -28,7 +28,7 @@ func TestSyslogSelfRegisters(t *testing.T) {
 
 func TestSyslogIsFoundByName(t *testing.T) {
 	// test
-	p, err := For(logger, "syslog", map[interface{}]interface{}{})
+	p, err := For(logger, "syslog", map[string]interface{}{})
 	assert.NoError(t, err)
 
 	// verify
@@ -38,15 +38,15 @@ func TestSyslogIsFoundByName(t *testing.T) {
 func TestSyslogConfiguration(t *testing.T) {
 	for _, tt := range []struct {
 		desc     string
-		config   map[interface{}]interface{}
+		config   map[string]interface{}
 		expected []corev1.ServicePort
 	}{
-		{"Empty configuration", map[interface{}]interface{}{}, []corev1.ServicePort{}},
+		{"Empty configuration", map[string]interface{}{}, []corev1.ServicePort{}},
 		{"UDP port configuration",
-			map[interface{}]interface{}{"udp": map[interface{}]interface{}{"listen_address": "0.0.0.0:1234"}},
+			map[string]interface{}{"udp": map[string]interface{}{"listen_address": "0.0.0.0:1234"}},
 			[]corev1.ServicePort{{Name: "syslog", Port: 1234, Protocol: corev1.ProtocolUDP}}},
 		{"TCP port configuration",
-			map[interface{}]interface{}{"tcp": map[interface{}]interface{}{"listen_address": "0.0.0.0:1234"}},
+			map[string]interface{}{"tcp": map[string]interface{}{"listen_address": "0.0.0.0:1234"}},
 			[]corev1.ServicePort{{Name: "syslog", Port: 1234, Protocol: corev1.ProtocolTCP}}},
 	} {
 		t.Run(tt.desc, func(t *testing.T) {
diff --git a/internal/manifests/collector/parser/receiver/receiver_tcplog.go b/internal/manifests/collector/parser/receiver/receiver_tcplog.go
index c0232415a9..c749805bc8 100644
--- a/internal/manifests/collector/parser/receiver/receiver_tcplog.go
+++ b/internal/manifests/collector/parser/receiver/receiver_tcplog.go
@@ -30,13 +30,13 @@ const parserNameTcpLog = "__tcplog"
 
 // TcpLogReceiverParser parses the configuration for TCP log receivers.
 type TcpLogReceiverParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewTcpLogReceiverParser builds a new parser for TCP log receivers.
-func NewTcpLogReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewTcpLogReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &TcpLogReceiverParser{
 		logger: logger,
 		name:   name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_tcplog_test.go b/internal/manifests/collector/parser/receiver/receiver_tcplog_test.go
index 04b4eb03be..25e07c6668 100644
--- a/internal/manifests/collector/parser/receiver/receiver_tcplog_test.go
+++ b/internal/manifests/collector/parser/receiver/receiver_tcplog_test.go
@@ -28,7 +28,7 @@ func TestTcpLogSelfRegisters(t *testing.T) {
 
 func TestTcpLogIsFoundByName(t *testing.T) {
 	// test
-	p, err := For(logger, "tcplog", map[interface{}]interface{}{})
+	p, err := For(logger, "tcplog", map[string]interface{}{})
 	assert.NoError(t, err)
 
 	// verify
@@ -38,12 +38,12 @@ func TestTcpLogIsFoundByName(t *testing.T) {
 func TestTcpLogConfiguration(t *testing.T) {
 	for _, tt := range []struct {
 		desc     string
-		config   map[interface{}]interface{}
+		config   map[string]interface{}
 		expected []corev1.ServicePort
 	}{
-		{"Empty configuration", map[interface{}]interface{}{}, []corev1.ServicePort{}},
+		{"Empty configuration", map[string]interface{}{}, []corev1.ServicePort{}},
 		{"TCP port configuration",
-			map[interface{}]interface{}{"listen_address": "0.0.0.0:1234"},
+			map[string]interface{}{"listen_address": "0.0.0.0:1234"},
 			[]corev1.ServicePort{{Name: "tcplog", Port: 1234, Protocol: corev1.ProtocolTCP}}},
 	} {
 		t.Run(tt.desc, func(t *testing.T) {
diff --git a/internal/manifests/collector/parser/receiver/receiver_test.go b/internal/manifests/collector/parser/receiver/receiver_test.go
index 44cb04519d..416c56149b 100644
--- a/internal/manifests/collector/parser/receiver/receiver_test.go
+++ b/internal/manifests/collector/parser/receiver/receiver_test.go
@@ -91,7 +91,7 @@ func TestReceiverParsePortFromEndpoint(t *testing.T) {
 
 func TestReceiverFailsWhenPortIsntString(t *testing.T) {
 	// prepare
-	config := map[interface{}]interface{}{
+	config := map[string]interface{}{
 		"endpoint": 123,
 	}
 
@@ -105,7 +105,7 @@ func TestReceiverFailsWhenPortIsntString(t *testing.T) {
 func TestIgnorekubeletstatsEndpoint(t *testing.T) {
 	// ignore "kubeletstats" receiver endpoint field, this is special case
 	// as this receiver gets parsed by generic receiver parser
-	builder := NewGenericReceiverParser(logger, "kubeletstats", map[interface{}]interface{}{
+	builder := NewGenericReceiverParser(logger, "kubeletstats", map[string]interface{}{
 		"endpoint": "0.0.0.0:9000",
 	})
 
@@ -119,7 +119,7 @@ func TestIgnorekubeletstatsEndpoint(t *testing.T) {
 
 func TestReceiverFallbackWhenNotRegistered(t *testing.T) {
 	// test
-	p, err := For(logger, "myreceiver", map[interface{}]interface{}{})
+	p, err := For(logger, "myreceiver", map[string]interface{}{})
 	assert.NoError(t, err)
 
 	// test
@@ -129,13 +129,13 @@ func TestReceiverFallbackWhenNotRegistered(t *testing.T) {
 func TestReceiverShouldFindRegisteredParser(t *testing.T) {
 	// prepare
 	builderCalled := false
-	Register("mock", func(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+	Register("mock", func(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 		builderCalled = true
 		return &mockParser{}
 	})
 
 	// test
-	_, _ = For(logger, "mock", map[interface{}]interface{}{})
+	_, _ = For(logger, "mock", map[string]interface{}{})
 
 	// verify
 	assert.True(t, builderCalled)
@@ -154,7 +154,7 @@ func (m *mockParser) ParserName() string {
 
 func TestSkipPortsForScrapers(t *testing.T) {
 	for receiver := range scraperReceivers {
-		builder := NewGenericReceiverParser(logger, receiver, map[interface{}]interface{}{
+		builder := NewGenericReceiverParser(logger, receiver, map[string]interface{}{
 			"endpoint": "0.0.0.0:42069",
 		})
 		ports, err := builder.Ports()
diff --git a/internal/manifests/collector/parser/receiver/receiver_udplog.go b/internal/manifests/collector/parser/receiver/receiver_udplog.go
index 4f55e5b492..143f8df689 100644
--- a/internal/manifests/collector/parser/receiver/receiver_udplog.go
+++ b/internal/manifests/collector/parser/receiver/receiver_udplog.go
@@ -30,13 +30,13 @@ const parserNameUdpLog = "__udplog"
 
 // UdpLogReceiverParser parses the configuration for UDP log receivers.
 type UdpLogReceiverParser struct {
-	config map[interface{}]interface{}
+	config map[string]interface{}
 	logger logr.Logger
 	name   string
 }
 
 // NewUdpLogReceiverParser builds a new parser for UDP log receivers.
-func NewUdpLogReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewUdpLogReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &UdpLogReceiverParser{
 		logger: logger,
 		name:   name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_udplog_test.go b/internal/manifests/collector/parser/receiver/receiver_udplog_test.go
index 1b12191ed5..7c52520df2 100644
--- a/internal/manifests/collector/parser/receiver/receiver_udplog_test.go
+++ b/internal/manifests/collector/parser/receiver/receiver_udplog_test.go
@@ -28,7 +28,7 @@ func TestUdpLogSelfRegisters(t *testing.T) {
 
 func TestUdpLogIsFoundByName(t *testing.T) {
 	// test
-	p, err := For(logger, "udplog", map[interface{}]interface{}{})
+	p, err := For(logger, "udplog", map[string]interface{}{})
 	assert.NoError(t, err)
 
 	// verify
@@ -38,12 +38,12 @@ func TestUdpLogIsFoundByName(t *testing.T) {
 func TestUdpLogConfiguration(t *testing.T) {
 	for _, tt := range []struct {
 		desc     string
-		config   map[interface{}]interface{}
+		config   map[string]interface{}
 		expected []corev1.ServicePort
 	}{
-		{"Empty configuration", map[interface{}]interface{}{}, []corev1.ServicePort{}},
+		{"Empty configuration", map[string]interface{}{}, []corev1.ServicePort{}},
 		{"UDP port configuration",
-			map[interface{}]interface{}{"listen_address": "0.0.0.0:1234"},
+			map[string]interface{}{"listen_address": "0.0.0.0:1234"},
 			[]corev1.ServicePort{{Name: "udplog", Port: 1234, Protocol: corev1.ProtocolUDP}}},
 	} {
 		t.Run(tt.desc, func(t *testing.T) {
diff --git a/internal/manifests/collector/parser/receiver/receiver_wavefront.go b/internal/manifests/collector/parser/receiver/receiver_wavefront.go
index f2eafb8556..8e7498047d 100644
--- a/internal/manifests/collector/parser/receiver/receiver_wavefront.go
+++ b/internal/manifests/collector/parser/receiver/receiver_wavefront.go
@@ -23,7 +23,7 @@ import (
 const parserNameWavefront = "__wavefront"
 
 // NewWavefrontReceiverParser builds a new parser for Wavefront receivers, from the contrib repository.
-func NewWavefrontReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewWavefrontReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_zipkin-scribe.go b/internal/manifests/collector/parser/receiver/receiver_zipkin-scribe.go
index 8f8d9fe210..d57d6d3cd0 100644
--- a/internal/manifests/collector/parser/receiver/receiver_zipkin-scribe.go
+++ b/internal/manifests/collector/parser/receiver/receiver_zipkin-scribe.go
@@ -23,7 +23,7 @@ import (
 const parserNameZipkinScribe = "__zipkinscribe"
 
 // NewZipkinScribeReceiverParser builds a new parser for ZipkinScribe receivers.
-func NewZipkinScribeReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewZipkinScribeReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	return &GenericReceiver{
 		logger:      logger,
 		name:        name,
diff --git a/internal/manifests/collector/parser/receiver/receiver_zipkin.go b/internal/manifests/collector/parser/receiver/receiver_zipkin.go
index debbf8e9a4..81ddae4f45 100644
--- a/internal/manifests/collector/parser/receiver/receiver_zipkin.go
+++ b/internal/manifests/collector/parser/receiver/receiver_zipkin.go
@@ -24,7 +24,7 @@ import (
 const parserNameZipkin = "__zipkin"
 
 // NewZipkinReceiverParser builds a new parser for Zipkin receivers.
-func NewZipkinReceiverParser(logger logr.Logger, name string, config map[interface{}]interface{}) parser.ComponentPortParser {
+func NewZipkinReceiverParser(logger logr.Logger, name string, config map[string]interface{}) parser.ComponentPortParser {
 	http := "http"
 	return &GenericReceiver{
 		logger:             logger,
diff --git a/internal/manifests/collector/podmonitor.go b/internal/manifests/collector/podmonitor.go
index 86157c4138..d1722c8c04 100644
--- a/internal/manifests/collector/podmonitor.go
+++ b/internal/manifests/collector/podmonitor.go
@@ -80,18 +80,7 @@ func PodMonitor(params manifests.Params) (*monitoringv1.PodMonitor, error) {
 }
 
 func metricsEndpointsFromConfig(logger logr.Logger, otelcol v1beta1.OpenTelemetryCollector) []monitoringv1.PodMetricsEndpoint {
-	// TODO: https://github.com/open-telemetry/opentelemetry-operator/issues/2603
-	cfgStr, err := otelcol.Spec.Config.Yaml()
-	if err != nil {
-		logger.V(2).Error(err, "Error while marshaling to YAML")
-		return []monitoringv1.PodMetricsEndpoint{}
-	}
-	config, err := adapters.ConfigFromString(cfgStr)
-	if err != nil {
-		logger.V(2).Error(err, "Error while parsing the configuration")
-		return []monitoringv1.PodMetricsEndpoint{}
-	}
-	exporterPorts, err := adapters.ConfigToComponentPorts(logger, adapters.ComponentTypeExporter, config)
+	exporterPorts, err := adapters.PortsForExporters(logger, otelcol.Spec.Config)
 	if err != nil {
 		logger.Error(err, "couldn't build endpoints to podMonitors from configuration")
 		return []monitoringv1.PodMetricsEndpoint{}
diff --git a/internal/manifests/collector/rbac.go b/internal/manifests/collector/rbac.go
index 4af9223996..64cacc13c0 100644
--- a/internal/manifests/collector/rbac.go
+++ b/internal/manifests/collector/rbac.go
@@ -25,17 +25,7 @@ import (
 )
 
 func ClusterRole(params manifests.Params) (*rbacv1.ClusterRole, error) {
-	confStr, err := params.OtelCol.Spec.Config.Yaml()
-	if err != nil {
-		return nil, err
-	}
-
-	configFromString, err := adapters.ConfigFromString(confStr)
-	if err != nil {
-		params.Log.Error(err, "couldn't extract the configuration from the context")
-		return nil, nil
-	}
-	rules := adapters.ConfigToRBAC(params.Log, configFromString)
+	rules := adapters.ConfigToRBAC(params.Log, params.OtelCol.Spec.Config)
 
 	if len(rules) == 0 {
 		return nil, nil
@@ -55,16 +45,7 @@ func ClusterRole(params manifests.Params) (*rbacv1.ClusterRole, error) {
 }
 
 func ClusterRoleBinding(params manifests.Params) (*rbacv1.ClusterRoleBinding, error) {
-	confStr, err := params.OtelCol.Spec.Config.Yaml()
-	if err != nil {
-		return nil, err
-	}
-	configFromString, err := adapters.ConfigFromString(confStr)
-	if err != nil {
-		params.Log.Error(err, "couldn't extract the configuration from the context")
-		return nil, nil
-	}
-	rules := adapters.ConfigToRBAC(params.Log, configFromString)
+	rules := adapters.ConfigToRBAC(params.Log, params.OtelCol.Spec.Config)
 
 	if len(rules) == 0 {
 		return nil, nil
diff --git a/internal/manifests/collector/service.go b/internal/manifests/collector/service.go
index 7306943402..84008fc953 100644
--- a/internal/manifests/collector/service.go
+++ b/internal/manifests/collector/service.go
@@ -90,19 +90,7 @@ func MonitoringService(params manifests.Params) (*corev1.Service, error) {
 func Service(params manifests.Params) (*corev1.Service, error) {
 	name := naming.Service(params.OtelCol.Name)
 	labels := manifestutils.Labels(params.OtelCol.ObjectMeta, name, params.OtelCol.Spec.Image, ComponentOpenTelemetryCollector, []string{})
-
-	out, err := params.OtelCol.Spec.Config.Yaml()
-	if err != nil {
-		return nil, err
-	}
-
-	configFromString, err := adapters.ConfigFromString(out)
-	if err != nil {
-		params.Log.Error(err, "couldn't extract the configuration from the context")
-		return nil, err
-	}
-
-	ports, err := adapters.ConfigToPorts(params.Log, configFromString)
+	ports, err := adapters.ConfigToPorts(params.Log, params.OtelCol.Spec.Config)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/manifests/collector/servicemonitor.go b/internal/manifests/collector/servicemonitor.go
index 1713ccfe50..d7ebd217de 100644
--- a/internal/manifests/collector/servicemonitor.go
+++ b/internal/manifests/collector/servicemonitor.go
@@ -79,19 +79,7 @@ func ServiceMonitor(params manifests.Params) (*monitoringv1.ServiceMonitor, erro
 }
 
 func endpointsFromConfig(logger logr.Logger, otelcol v1beta1.OpenTelemetryCollector) []monitoringv1.Endpoint {
-	// TODO: https://github.com/open-telemetry/opentelemetry-operator/issues/2603
-	cfgStr, err := otelcol.Spec.Config.Yaml()
-	if err != nil {
-		logger.V(2).Error(err, "Error while marshaling to YAML")
-		return []monitoringv1.Endpoint{}
-	}
-	c, err := adapters.ConfigFromString(cfgStr)
-	if err != nil {
-		logger.V(2).Error(err, "Error while parsing the configuration")
-		return []monitoringv1.Endpoint{}
-	}
-
-	exporterPorts, err := adapters.ConfigToComponentPorts(logger, adapters.ComponentTypeExporter, c)
+	exporterPorts, err := adapters.PortsForExporters(logger, otelcol.Spec.Config)
 	if err != nil {
 		logger.Error(err, "couldn't build service monitors from configuration")
 		return []monitoringv1.Endpoint{}

From c2ebd383a345ec4160ffee19901b9b1f5a92ac6c Mon Sep 17 00:00:00 2001
From: Jacob Aronoff <jacobaronoff45@gmail.com>
Date: Wed, 17 Apr 2024 15:38:44 -0400
Subject: [PATCH 6/6] cycle

---
 go.mod | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/go.mod b/go.mod
index 18d637cb0d..386786b4af 100644
--- a/go.mod
+++ b/go.mod
@@ -14,7 +14,6 @@ require (
 	github.com/go-kit/log v0.2.1
 	github.com/go-logr/logr v1.4.1
 	github.com/json-iterator/go v1.1.12
-	github.com/mitchellh/mapstructure v1.5.0
 	github.com/oklog/run v1.1.0
 	github.com/oklog/ulid/v2 v2.1.0
 	github.com/open-telemetry/opamp-go v0.14.0
@@ -161,6 +160,7 @@ require (
 	github.com/metalmatze/signal v0.0.0-20210307161603-1c9aa721a97a // indirect
 	github.com/miekg/dns v1.1.58 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect