Add support for a supplemental YAML configuration for the CloudWatchA…

…gent (#241)

apis/v1alpha1/amazoncloudwatchagent_types.go

@@ -167,6 +167,9 @@ type AmazonCloudWatchAgentSpec struct {
 	// Config is the raw JSON to be used as the collector's configuration. Refer to the OpenTelemetry Collector documentation for details.
 	// +required
 	Config string `json:"config,omitempty"`
+	// Config is the raw YAML to be used as the collector's configuration. Refer to the OpenTelemetry Collector documentation for details.
+	// +optional
+	OtelConfig string `json:"otelConfig,omitempty"`
 	// VolumeMounts represents the mount points to use in the underlying collector deployment(s)
 	// +optional
 	// +listType=atomic

apis/v1alpha2/amazoncloudwatchagent_types.go

@@ -92,6 +92,9 @@ type AmazonCloudWatchAgentSpec struct {
 	// Config is the raw JSON to be used as the collector's configuration. Refer to the OpenTelemetry Collector documentation for details.
 	// +required
 	Config string `json:"config,omitempty"`
+	// Config is the raw YAML to be used as the collector's configuration. Refer to the OpenTelemetry Collector documentation for details.
+	// +optional
+	OtelConfig string `json:"otelConfig,omitempty"`
 	// VolumeMounts represents the mount points to use in the underlying collector deployment(s)
 	// +optional
 	// +listType=atomic

internal/config/main.go

@@ -12,7 +12,8 @@ import (
 )
 
 const (
-	defaultCollectorConfigMapEntry = "cwagentconfig.json"
+	defaultCollectorConfigMapEntry     = "cwagentconfig.json"
+	defaultOtelCollectorConfigMapEntry = "cwagentotelconfig.yaml"
 )
 
 // Config holds the static configuration for this operator.
@@ -21,6 +22,7 @@ type Config struct {
 	autoInstrumentationPythonImage      string
 	collectorImage                      string
 	collectorConfigMapEntry             string
+	otelCollectorConfigMapEntry         string
 	autoInstrumentationDotNetImage      string
 	autoInstrumentationGoImage          string
 	autoInstrumentationApacheHttpdImage string
@@ -36,9 +38,10 @@ type Config struct {
 func New(opts ...Option) Config {
 	// initialize with the default values
 	o := options{
-		collectorConfigMapEntry: defaultCollectorConfigMapEntry,
-		logger:                  logf.Log.WithName("config"),
-		version:                 version.Get(),
+		collectorConfigMapEntry:     defaultCollectorConfigMapEntry,
+		otelCollectorConfigMapEntry: defaultOtelCollectorConfigMapEntry,
+		logger:                      logf.Log.WithName("config"),
+		version:                     version.Get(),
 	}
 	for _, opt := range opts {
 		opt(&o)
@@ -47,6 +50,7 @@ func New(opts ...Option) Config {
 	return Config{
 		collectorImage:                      o.collectorImage,
 		collectorConfigMapEntry:             o.collectorConfigMapEntry,
+		otelCollectorConfigMapEntry:         o.otelCollectorConfigMapEntry,
 		logger:                              o.logger,
 		autoInstrumentationJavaImage:        o.autoInstrumentationJavaImage,
 		autoInstrumentationNodeJSImage:      o.autoInstrumentationNodeJSImage,
@@ -66,11 +70,16 @@ func (c *Config) CollectorImage() string {
 	return c.collectorImage
 }
 
-// CollectorConfigMapEntry represents the configuration file name for the collector. Immutable.
+// CollectorConfigMapEntry represents the configuration JSON file name for the collector. Immutable.
 func (c *Config) CollectorConfigMapEntry() string {
 	return c.collectorConfigMapEntry
 }
 
+// OtelCollectorConfigMapEntry represents the configuration YAML file name for the collector. Immutable.
+func (c *Config) OtelCollectorConfigMapEntry() string {
+	return c.otelCollectorConfigMapEntry
+}
+
 // AutoInstrumentationJavaImage returns OpenTelemetry Java auto-instrumentation container image.
 func (c *Config) AutoInstrumentationJavaImage() string {
 	return c.autoInstrumentationJavaImage

internal/config/main_test.go

@@ -15,10 +15,12 @@ func TestNewConfig(t *testing.T) {
 	// prepare
 	cfg := config.New(
 		config.WithCollectorImage("some-image"),
-		config.WithCollectorConfigMapEntry("some-config.yaml"),
+		config.WithCollectorConfigMapEntry("some-config.json"),
+		config.WithOtelCollectorConfigMapEntry("some-otel-config.yaml"),
 	)
 
 	// test
 	assert.Equal(t, "some-image", cfg.CollectorImage())
-	assert.Equal(t, "some-config.yaml", cfg.CollectorConfigMapEntry())
+	assert.Equal(t, "some-config.json", cfg.CollectorConfigMapEntry())
+	assert.Equal(t, "some-otel-config.yaml", cfg.OtelCollectorConfigMapEntry())
 }

internal/config/options.go

@@ -27,6 +27,7 @@ type options struct {
 	autoInstrumentationNginxImage       string
 	collectorImage                      string
 	collectorConfigMapEntry             string
+	otelCollectorConfigMapEntry         string
 	dcgmExporterImage                   string
 	neuronMonitorImage                  string
 	labelsFilter                        []string
@@ -42,6 +43,11 @@ func WithCollectorConfigMapEntry(s string) Option {
 		o.collectorConfigMapEntry = s
 	}
 }
+func WithOtelCollectorConfigMapEntry(s string) Option {
+	return func(o *options) {
+		o.otelCollectorConfigMapEntry = s
+	}
+}
 func WithLogger(logger logr.Logger) Option {
 	return func(o *options) {
 		o.logger = logger

internal/manifests/collector/adapters/config_from.go

@@ -58,6 +58,7 @@ type Traces struct {
 type MetricsCollected struct {
 	StatsD   *statsD   `json:"statsd,omitempty"`
 	CollectD *collectD `json:"collectd,omitempty"`
+	OTLP     *otlp     `json:"otlp,omitempty"`
 	JMX      *jmx      `json:"jmx,omitempty"`
 }
 
@@ -66,6 +67,7 @@ type LogMetricsCollected struct {
 	ApplicationSignals *AppSignals `json:"application_signals,omitempty"`
 	AppSignals         *AppSignals `json:"app_signals,omitempty"`
 	Kubernetes         *kubernetes `json:"kubernetes,omitempty"`
+	OTLP               *otlp       `json:"otlp,omitempty"`
 }
 
 type TracesCollected struct {

internal/manifests/collector/adapters/config_to_ports.go

@@ -4,19 +4,24 @@
 package adapters
 
 import (
+	"fmt"
 	"net"
+	"sort"
 	"strconv"
 	"strings"
 
 	"github.com/go-logr/logr"
 	"github.com/mitchellh/mapstructure"
+	corev1 "k8s.io/api/core/v1"
+
+	"github.com/aws/amazon-cloudwatch-agent-operator/internal/manifests/collector/parser"
+	receiverParser "github.com/aws/amazon-cloudwatch-agent-operator/internal/manifests/collector/parser/receiver"
 )
 
 type ComponentType int
 
 const (
 	ComponentTypeReceiver ComponentType = iota
-	ComponentTypeExporter
 )
 
 func (c ComponentType) String() string {
@@ -58,3 +63,82 @@ func ConfigToMetricsPort(logger logr.Logger, config map[interface{}]interface{})
 
 	return int32(i64), nil
 }
+
+func GetServicePortsFromCWAgentOtelConfig(logger logr.Logger, config map[interface{}]interface{}) ([]corev1.ServicePort, error) {
+	ports, err := ConfigToComponentPorts(logger, ComponentTypeReceiver, config)
+	if err != nil {
+		logger.Error(err, "there was a problem while getting the ports from the receivers")
+		return nil, err
+	}
+
+	return ports, nil
+}
+
+// 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{}) ([]corev1.ServicePort, 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:
+	// 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)
+
+	if compEnabled == nil {
+		return nil, fmt.Errorf("no enabled %ss available as part of the configuration", cType)
+	}
+
+	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] {
+			continue
+		}
+		extractedComponent, ok := val.(map[interface{}]interface{})
+		if !ok {
+			logger.V(2).Info("component doesn't seem to be a map of properties", cType.String(), key)
+			extractedComponent = map[interface{}]interface{}{}
+		}
+
+		cmptName := key.(string)
+		var cmptParser parser.ComponentPortParser
+		var err error
+		cmptParser, err = receiverParser.For(logger, cmptName, extractedComponent)
+		if err != nil {
+			logger.V(2).Info("no parser found for '%s'", cmptName)
+			continue
+		}
+
+		exprtPorts, err := cmptParser.Ports()
+		if err != nil {
+			logger.Error(err, "parser for '%s' has returned an error: %w", cmptName, err)
+			continue
+		}
+
+		if len(exprtPorts) > 0 {
+			ports = append(ports, exprtPorts...)
+		}
+	}
+
+	sort.Slice(ports, func(i, j int) bool {
+		return ports[i].Name < ports[j].Name
+	})
+
+	return ports, nil
+}

internal/manifests/collector/config_replace.go

@@ -6,6 +6,8 @@ package collector
 import (
 	"encoding/json"
 
+	"gopkg.in/yaml.v2"
+
 	_ "github.com/prometheus/prometheus/discovery/install" // Package install has the side-effect of registering all builtin.
 
 	"github.com/aws/amazon-cloudwatch-agent-operator/apis/v1alpha1"
@@ -25,3 +27,16 @@ func ReplaceConfig(instance v1alpha1.AmazonCloudWatchAgent) (string, error) {
 
 	return string(out), nil
 }
+
+func ReplaceOtelConfig(instance v1alpha1.AmazonCloudWatchAgent) (string, error) {
+	config, err := adapters.ConfigFromString(instance.Spec.OtelConfig)
+	if err != nil {
+		return "", err
+	}
+
+	out, err := yaml.Marshal(config)
+	if err != nil {
+		return "", err
+	}
+	return string(out), nil
+}

internal/manifests/collector/configmap.go

@@ -18,19 +18,30 @@ func ConfigMap(params manifests.Params) (*corev1.ConfigMap, error) {
 
 	replacedConf, err := ReplaceConfig(params.OtelCol)
 	if err != nil {
-		params.Log.V(2).Info("failed to update prometheus config to use sharded targets: ", "err", err)
+		params.Log.V(2).Info("failed to update config: ", "err", err)
 		return nil, err
 	}
 
+	sourceDataMap := map[string]string{
+		params.Config.CollectorConfigMapEntry(): replacedConf,
+	}
+
+	if params.OtelCol.Spec.OtelConfig != "" {
+		replacedOtelConfig, err := ReplaceOtelConfig(params.OtelCol)
+		if err != nil {
+			params.Log.V(2).Info("failed to update otel config: ", "err", err)
+			return nil, err
+		}
+		sourceDataMap[params.Config.OtelCollectorConfigMapEntry()] = replacedOtelConfig
+	}
+
 	return &corev1.ConfigMap{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:        name,
 			Namespace:   params.OtelCol.Namespace,
 			Labels:      labels,
 			Annotations: params.OtelCol.Annotations,
 		},
-		Data: map[string]string{
-			"cwagentconfig.json": replacedConf,
-		},
+		Data: sourceDataMap,
 	}, nil
 }

internal/manifests/collector/configmap_test.go

@@ -10,17 +10,17 @@ import (
 )
 
 func TestDesiredConfigMap(t *testing.T) {
-	expectedLables := map[string]string{
+	expectedLabels := map[string]string{
 		"app.kubernetes.io/managed-by": "amazon-cloudwatch-agent-operator",
 		"app.kubernetes.io/instance":   "default.test",
 		"app.kubernetes.io/part-of":    "amazon-cloudwatch-agent",
 		"app.kubernetes.io/version":    "0.47.0",
 	}
 
 	t.Run("should return expected cwagent config map", func(t *testing.T) {
-		expectedLables["app.kubernetes.io/component"] = "amazon-cloudwatch-agent"
-		expectedLables["app.kubernetes.io/name"] = "test"
-		expectedLables["app.kubernetes.io/version"] = "0.0.0"
+		expectedLabels["app.kubernetes.io/component"] = "amazon-cloudwatch-agent"
+		expectedLabels["app.kubernetes.io/name"] = "test"
+		expectedLabels["app.kubernetes.io/version"] = "0.0.0"
 
 		expectedData := map[string]string{
 			"cwagentconfig.json": `{"logs":{"metrics_collected":{"application_signals":{},"kubernetes":{"enhanced_container_insights":true}}},"traces":{"traces_collected":{"application_signals":{}}}}`,
@@ -31,8 +31,56 @@ func TestDesiredConfigMap(t *testing.T) {
 
 		assert.NoError(t, err)
 		assert.Equal(t, "test", actual.Name)
-		assert.Equal(t, expectedLables, actual.Labels)
+		assert.Equal(t, expectedLabels, actual.Labels)
 		assert.Equal(t, expectedData, actual.Data)
 
 	})
 }
+
+func TestDesiredConfigMapWithOtelConfigSupplied(t *testing.T) {
+	expectedLabels := map[string]string{
+		"app.kubernetes.io/managed-by": "amazon-cloudwatch-agent-operator",
+		"app.kubernetes.io/instance":   "default.test",
+		"app.kubernetes.io/part-of":    "amazon-cloudwatch-agent",
+		"app.kubernetes.io/version":    "0.47.0",
+	}
+
+	t.Run("should return expected cwagent config map", func(t *testing.T) {
+		expectedLabels["app.kubernetes.io/component"] = "amazon-cloudwatch-agent"
+		expectedLabels["app.kubernetes.io/name"] = "test"
+		expectedLabels["app.kubernetes.io/version"] = "0.0.0"
+
+		expectedData := map[string]string{
+			"cwagentconfig.json": `{"logs":{"metrics_collected":{"application_signals":{},"kubernetes":{"enhanced_container_insights":true}}},"traces":{"traces_collected":{"application_signals":{}}}}`,
+			"cwagentotelconfig.yaml": `receivers:
+  jaeger:
+    protocols:
+      grpc:
+  prometheus:
+    config:
+      scrape_configs:
+      - job_name: otel-collector
+        scrape_interval: 10s
+        static_configs:
+          - targets: [ '0.0.0.0:8888', '0.0.0.0:9999' ]
+
+exporters:
+  debug:
+
+service:
+  pipelines:
+    metrics:
+      receivers: [prometheus, jaeger]
+      exporters: [debug]`,
+		}
+
+		param := otelConfigParams()
+		actual, err := ConfigMap(param)
+
+		assert.NoError(t, err)
+		assert.Equal(t, "test", actual.Name)
+		assert.Equal(t, expectedLabels, actual.Labels)
+		assert.Equal(t, expectedData["cwagentconfig.json"], actual.Data["cwagentconfig.json"])
+		assert.YAMLEq(t, expectedData["cwagentotelconfig.yaml"], actual.Data["cwagentotelconfig.yaml"])
+	})
+}