Keep only DogStatsD parts

The API exporter will be added on a future PR

Author: mx-psi

exporter/datadogexporter/README.md

@@ -1,22 +1,10 @@
 # Datadog Exporter
 
-This exporter sends metric data to [Datadog](https://datadoghq.com).
+This exporter sends metric data to [Datadog](https://datadoghq.com) using DogStatsD.
 
 ## Configuration
 
-The metrics exporter has two modes:
-  - If sending metrics through DogStatsD (the default mode), there are no required settings. 
-  - If sending metrics without an Agent the mode must be set explicitly and
-      you must provide a [Datadog API key](https://app.datadoghq.com/account/settings#api).
- ```yaml
-datadog:
-  api:
-    key: "<API key>"
-    # site: datadoghq.eu for sending data to the Datadog EU site
-   metrics:
-     mode: agentless
- ```
-
+There are no required settings.
 The hostname, environment, service and version can be set in the configuration for unified service tagging.
 
-See the sample configuration file under the `example` folder for other available options.
+See the sample configuration file under the `example` folder for all available options.

exporter/datadogexporter/config.go

@@ -15,34 +15,11 @@
 package datadogexporter
 
 import (
-	"errors"
 	"fmt"
-	"strings"
 
 	"go.opentelemetry.io/collector/config/configmodels"
 )
 
-var (
-	errUnsetAPIKey = errors.New("the Datadog API key is unset")
-)
-
-const (
-	NoneMode      = "none"
-	AgentlessMode = "agentless"
-	DogStatsDMode = "dogstatsd"
-)
-
-// APIConfig defines the API configuration options
-type APIConfig struct {
-	// Key is the Datadog API key to associate your Agent's data with your organization.
-	// Create a new API key here: https://app.datadoghq.com/account/settings
-	Key string `mapstructure:"key"`
-
-	// Site is the site of the Datadog intake to send data to.
-	// The default value is "datadoghq.com".
-	Site string `mapstructure:"site"`
-}
-
 // DogStatsDConfig defines the DogStatsd related configuration
 type DogStatsDConfig struct {
 	// Endpoint is the DogStatsD address.
@@ -54,22 +31,12 @@ type DogStatsDConfig struct {
 	Telemetry bool `mapstructure:"telemetry"`
 }
 
-// AgentlessConfig defines the Agentless related configuration
-type AgentlessConfig struct {
-	// Endpoint is the host of the Datadog intake server to send metrics to.
-	// If unset, the value is obtained from the Site.
-	Endpoint string `mapstructure:"endpoint"`
-}
-
 // MetricsConfig defines the metrics exporter specific configuration options
 type MetricsConfig struct {
 	// Namespace is the namespace under which the metrics are sent
 	// By default metrics are not namespaced
 	Namespace string `mapstructure:"namespace"`
 
-	// Mode is the metrics sending mode: either 'dogstatsd' or 'agentless'
-	Mode string `mapstructure:"mode"`
-
 	// Percentiles states whether to report percentiles for summary metrics,
 	// including the minimum and maximum
 	Percentiles bool `mapstructure:"report_percentiles"`
@@ -79,9 +46,6 @@ type MetricsConfig struct {
 
 	// DogStatsD defines the DogStatsD configuration options.
 	DogStatsD DogStatsDConfig `mapstructure:"dogstatsd"`
-
-	// Agentless defines the Agentless configuration options.
-	Agentless AgentlessConfig `mapstructure:"agentless"`
 }
 
 // TagsConfig defines the tag-related configuration
@@ -142,33 +106,12 @@ type Config struct {
 
 	TagsConfig `mapstructure:",squash"`
 
-	// API defines the Datadog API configuration.
-	API APIConfig `mapstructure:"api"`
-
 	// Metrics defines the Metrics exporter specific configuration
 	Metrics MetricsConfig `mapstructure:"metrics"`
 }
 
 // Sanitize tries to sanitize a given configuration
 func (c *Config) Sanitize() error {
-
-	if c.Metrics.Mode != AgentlessMode && c.Metrics.Mode != DogStatsDMode {
-		return fmt.Errorf("Metrics mode '%s' is not recognized", c.Metrics.Mode)
-	}
-
-	// Exactly one configuration for metrics must be set
-	if c.Metrics.Mode == AgentlessMode {
-		if c.API.Key == "" {
-			return errUnsetAPIKey
-		}
-
-		c.API.Key = strings.TrimSpace(c.API.Key)
-
-		// Set the endpoint based on the Site
-		if c.Metrics.Agentless.Endpoint == "" {
-			c.Metrics.Agentless.Endpoint = fmt.Sprintf("https://api.%s", c.API.Site)
-		}
-	}
-
+	// This will be useful on a future PR
 	return nil
 }

exporter/datadogexporter/config_test.go

@@ -37,95 +37,53 @@ func TestLoadConfig(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, cfg)
 
-	apiConfig := cfg.Exporters["datadog/api"].(*Config)
+	apiConfig := cfg.Exporters["datadog/dogstatsd"].(*Config)
 	err = apiConfig.Sanitize()
 
 	require.NoError(t, err)
 	assert.Equal(t, apiConfig, &Config{
 		ExporterSettings: configmodels.ExporterSettings{
-			NameVal: "datadog/api",
+			NameVal: "datadog/dogstatsd",
 			TypeVal: "datadog",
 		},
 
-		TagsConfig: TagsConfig{
-			Hostname: "customhostname",
-			Env:      "prod",
-			Service:  "myservice",
-			Version:  "myversion",
-			Tags:     []string{"example:tag"},
-		},
-
-		API: APIConfig{
-			Key:  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-			Site: "datadoghq.eu",
-		},
-
 		Metrics: MetricsConfig{
-			Mode:        AgentlessMode,
-			Namespace:   "opentelemetry",
-			Percentiles: false,
+			Percentiles: true,
 
 			DogStatsD: DogStatsDConfig{
 				Endpoint:  "127.0.0.1:8125",
 				Telemetry: true,
 			},
-
-			Agentless: AgentlessConfig{
-				Endpoint: "https://api.datadoghq.eu",
-			},
 		},
 	})
 
-	dogstatsdConfig := cfg.Exporters["datadog/dogstatsd"].(*Config)
+	dogstatsdConfig := cfg.Exporters["datadog/dogstatsd/config"].(*Config)
 	err = dogstatsdConfig.Sanitize()
 
 	require.NoError(t, err)
 	assert.Equal(t, dogstatsdConfig, &Config{
 		ExporterSettings: configmodels.ExporterSettings{
-			NameVal: "datadog/dogstatsd",
+			NameVal: "datadog/dogstatsd/config",
 			TypeVal: "datadog",
 		},
 
-		TagsConfig: TagsConfig{},
-		API:        APIConfig{Site: "datadoghq.com"},
+		TagsConfig: TagsConfig{
+			Hostname: "customhostname",
+			Env:      "prod",
+			Service:  "myservice",
+			Version:  "myversion",
+ 			Tags:     []string{"example:tag"},
+		},
 
 		Metrics: MetricsConfig{
-			Mode:        DogStatsDMode,
-			Percentiles: true,
+			Namespace:   "opentelemetry",
+			Percentiles: false,
+			Buckets:     true,
 			DogStatsD: DogStatsDConfig{
-				Endpoint:  "127.0.0.1:8125",
-				Telemetry: true,
+				Endpoint:  "localhost:5000",
+				Telemetry: false,
 			},
-
-			Agentless: AgentlessConfig{},
 		},
 	})
 
-	invalidConfig := cfg.Exporters["datadog/invalid"].(*Config)
-	err = invalidConfig.Sanitize()
-	require.Error(t, err)
-
-	invalidConfig2 := cfg.Exporters["datadog/agentless/invalid"].(*Config)
-	err = invalidConfig2.Sanitize()
-	require.Error(t, err)
-
-}
-
-// TestOverrideMetricsURL tests that the metrics URL is overridden
-// correctly when set manually.
-func TestOverrideMetricsURL(t *testing.T) {
-
-	const DebugEndpoint string = "http://localhost:8080"
-
-	cfg := Config{
-		API: APIConfig{Key: "notnull", Site: DefaultSite},
-		Metrics: MetricsConfig{
-			Mode:      AgentlessMode,
-			Agentless: AgentlessConfig{Endpoint: DebugEndpoint},
-		},
-	}
-
-	err := cfg.Sanitize()
-	require.NoError(t, err)
-	assert.Equal(t, cfg.Metrics.Agentless.Endpoint, DebugEndpoint)
 }

exporter/datadogexporter/example/config.yaml

@@ -35,39 +35,10 @@ exporters:
     #
     # tags: []
 
-    ## @param api - custom object - optional.
-    ## Specific API configuration for the agentless exporters.
-    #
-    # api:
-      ## @ param key - string - optional
-      ## The Datadog API key to associate your Agent's data with your organization.
-      ## Create a new API key here: https://app.datadoghq.com/account/settings
-      ##
-      ## This is required if using any agentless exporter.
-      #
-      # key: <YOUR API KEY>
-
-      ## @param site - string - optional - default: datadoghq.com
-      ## The site of the Datadog intake to send Agent data to.
-      ## Set to 'datadoghq.eu' to send data to the EU site.
-      #
-      # site: datadoghq.com
-
     ## @param metrics - custom object - optional
     ## Metric exporter specific configuration.
     #
     # metrics:
-      ## @param mode - string - optional - default: dogstatsd
-      ## The mode with which to send metrics.
-      ## It can be one of
-      ## - 'none' (to explicitly disable it)
-      ## - 'dogstatsd' (to send metrics to a DogStatsD endpoint)
-      ## - 'agentless' (to send metrics directly through the API)
-      ##
-      ## If the mode is 'agentless' the API key must be set.
-      #
-      # mode: dogstatsd
-
       ## @param namespace - string - optional
       ## The namespace with which to prefix all metrics.
       ## By default metrics are not namespaced.
@@ -100,16 +71,6 @@ exporters:
         ## Whether to send telemetry metrics about the number of custom metrics sent.
         #
         # telemetry: true
-
-      ## @param agentless - custom object - optional
-      ## Agentless metrics exporter specific configuration
-      #
-      # agentless:
-        ## @param endpoint - string - optional
-        ## The host of the Datadog intake server to send metrics to.
-        ## If unset the value is obtained through the `site` parameter in the `api` section.
-        #
-        # endpoint: https://api.datadoghq.com
 service:
   pipelines:
     traces:

exporter/datadogexporter/factory.go

@@ -53,23 +53,13 @@ func NewFactory() component.ExporterFactory {
 // createDefaultConfig creates the default exporter configuration
 func createDefaultConfig() configmodels.Exporter {
 	return &Config{
-		API: APIConfig{
-			Key:  "", // must be set if using API
-			Site: "datadoghq.com",
-		},
-
 		Metrics: MetricsConfig{
-			Mode:        DogStatsDMode,
 			Percentiles: true,
 
 			DogStatsD: DogStatsDConfig{
 				Endpoint:  "127.0.0.1:8125",
 				Telemetry: true,
 			},
-
-			Agentless: AgentlessConfig{
-				Endpoint: "", // set during config sanitization
-			},
 		},
 	}
 }

exporter/datadogexporter/factory_test.go

@@ -34,9 +34,7 @@ func TestCreateDefaultConfig(t *testing.T) {
 	cfg := factory.CreateDefaultConfig()
 
 	assert.Equal(t, cfg, &Config{
-		API: APIConfig{Site: "datadoghq.com"},
 		Metrics: MetricsConfig{
-			Mode:        DogStatsDMode,
 			Percentiles: true,
 			DogStatsD: DogStatsDConfig{
 				Endpoint:  "127.0.0.1:8125",
@@ -71,32 +69,7 @@ func TestCreateAgentMetricsExporter(t *testing.T) {
 	assert.NotNil(t, exp)
 }
 
-func TestCreateAPIMetricsExporter(t *testing.T) {
-	logger := zap.NewNop()
-
-	factories, err := componenttest.ExampleComponents()
-	assert.NoError(t, err)
-
-	factory := NewFactory()
-	factories.Exporters[configmodels.Type(typeStr)] = factory
-	cfg, err := configtest.LoadConfigFile(t, path.Join(".", "testdata", "config.yaml"), factories)
-
-	require.NoError(t, err)
-	require.NotNil(t, cfg)
-
-	ctx := context.Background()
-	exp, err := factory.CreateMetricsExporter(
-		ctx,
-		component.ExporterCreateParams{Logger: logger},
-		cfg.Exporters["datadog/api"],
-	)
-
-	// Not implemented
-	assert.NotNil(t, err)
-	assert.Nil(t, exp)
-}
-
-func TestCreateAPITraceExporter(t *testing.T) {
+func TestCreateTraceExporter(t *testing.T) {
 	logger := zap.NewNop()
 
 	factories, err := componenttest.ExampleComponents()
@@ -113,7 +86,7 @@ func TestCreateAPITraceExporter(t *testing.T) {
 	exp, err := factory.CreateTraceExporter(
 		ctx,
 		component.ExporterCreateParams{Logger: logger},
-		cfg.Exporters["datadog/api"],
+		cfg.Exporters["datadog/dogstatsd"],
 	)
 
 	// Not implemented

exporter/datadogexporter/metrics.go

@@ -35,14 +35,9 @@ type MetricsExporter interface {
 }
 
 func newMetricsExporter(logger *zap.Logger, cfg *Config) (MetricsExporter, error) {
-	switch cfg.Metrics.Mode {
-	case DogStatsDMode:
-		return newDogStatsDExporter(logger, cfg)
-	case NoneMode:
-		return nil, fmt.Errorf("Metrics exporter disabled for Datadog exporter")
-	}
-
-	return nil, fmt.Errorf("Unsupported mode: '%s'", cfg.Metrics.Mode)
+	// A different exporter will be added depending on configuration
+	// in the future
+	return newDogStatsDExporter(logger, cfg)
 }
 
 type MetricType int