Make DataType a separate type within Component

.chloggen/datatype-type-interface.yaml

@@ -0,0 +1,28 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver)
+component: component
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: "Change Type to an interface, introduce the new types ComponentType and DataType now implement it."
+
+# One or more tracking issues or pull requests related to the change
+issues: [9429]
+
+# (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: |
+  Creates ComponentType and DataType - ComponentType represents the names of components and DataType is an enum for Traces,Logs, and Metrics (and future signal types!).
+
+  NewType will now automatically create a DataType instead of ComponentType for the strings "traces", "logs", and "metrics". In addition, ID's zero value now contains a null value for Type - since it is now an interface."
+
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: ['api']

component/config.go

@@ -4,6 +4,7 @@
 package component // import "go.opentelemetry.io/collector/component"
 
 import (
+	"encoding"
 	"fmt"
 	"reflect"
 	"regexp"
@@ -109,18 +110,26 @@
 	return nil
 }
 
-// Type is the component type as it is used in the config.
-type Type struct {
+// Type represents the names of receivers (otlp, filelog, etc),
+// processors (batch, memory_limit, etc), or exporters (debug, rabbitmq)
+// It also includes the DataType - things like "metrics", "traces", "logs"
+type Type interface {
+	fmt.Stringer
+	encoding.TextMarshaler
+}
+
+// ComponentType is the component type as it is used in the config.
+type ComponentType struct { //revive:disable-line:exported
 	name string
 }
 
 // String returns the string representation of the type.
-func (t Type) String() string {
+func (t ComponentType) String() string {
 	return t.name
 }
 
 // MarshalText marshals returns the Type name.
-func (t Type) MarshalText() ([]byte, error) {
+func (t ComponentType) MarshalText() ([]byte, error) {
 	return []byte(t.name), nil
 }
 
@@ -135,14 +144,18 @@
 // - have at least one character,
 // - start with an ASCII alphabetic character and
 // - can only contain ASCII alphanumeric characters and '_'.
+// If the type string is a supported DataType, one is returned.  Otherwise, a ComponentType is returned.
 func NewType(ty string) (Type, error) {
 	if len(ty) == 0 {
-		return Type{}, fmt.Errorf("id must not be empty")
+		return ComponentType{}, fmt.Errorf("id must not be empty")
 	}
 	if !typeRegexp.MatchString(ty) {
-		return Type{}, fmt.Errorf("invalid character(s) in type %q", ty)
+		return ComponentType{}, fmt.Errorf("invalid character(s) in type %q", ty)
 	}
-	return Type{name: ty}, nil
+	if dataType, ok := DataTypeFromSignal(ty); ok {
+		return dataType, nil
+	}
+	return ComponentType{name: ty}, nil
 }
 
 // MustNewType creates a type. It panics if the type is invalid.
@@ -160,20 +173,40 @@
 
 // DataType is a special Type that represents the data types supported by the collector. We currently support
 // collecting metrics, traces and logs, this can expand in the future.
-type DataType = Type
-
-func mustNewDataType(strType string) DataType {
-	return MustNewType(strType)
-}
+type DataType string
 
 // Currently supported data types. Add new data types here when new types are supported in the future.
 var (
 	// DataTypeTraces is the data type tag for traces.
-	DataTypeTraces = mustNewDataType("traces")
+	DataTypeTraces DataType = "traces"
 
 	// DataTypeMetrics is the data type tag for metrics.
-	DataTypeMetrics = mustNewDataType("metrics")
+	DataTypeMetrics DataType = "metrics"
 
 	// DataTypeLogs is the data type tag for logs.
-	DataTypeLogs = mustNewDataType("logs")
+	DataTypeLogs DataType = "logs"
+
+	signalNameToDataType = map[string]DataType{
+		"logs":    DataTypeLogs,
+		"metrics": DataTypeMetrics,
+		"traces":  DataTypeTraces,
+	}
 )
+
+func (dt DataType) String() string {
+	return string(dt)
+}
+func (dt DataType) MarshalText() (text []byte, err error) {
+	return []byte(dt), nil
+}
+
+// DataTypeFromSignal takes in a string of a datatype, and returns a DataType and a bool.
+// The bool is set to true if the string corresponds to a supported DataType, else it is False.
+// if there is a matching DataType, it returns the matching DataType enum.  If not, it returns an empty string.
+func DataTypeFromSignal(s string) (DataType, bool) {
+	val, ok := signalNameToDataType[s]
+	if !ok {
+		return "", ok
+	}
+	return val, ok
+}

component/config_test.go

@@ -16,7 +16,7 @@ import (
 	"go.opentelemetry.io/collector/confmap"
 )
 
-var _ fmt.Stringer = Type{}
+var _ fmt.Stringer = ComponentType{}
 
 type configChildStruct struct {
 	Child    errConfig
@@ -423,6 +423,18 @@ func TestNewType(t *testing.T) {
 	}
 }
 
+func TestNewTypeDataType(t *testing.T) {
+	ty, err := NewType("logs")
+	require.NoError(t, err)
+	assert.Equal(t, ty, DataTypeLogs)
+
+	// hopefully this reminds us to update DataType when profiles get included
+	ty, err = NewType("profiles")
+	require.NoError(t, err)
+	assert.Equal(t, ty.(ComponentType).name, "profiles")
+
+}
+
 type configWithEmbeddedStruct struct {
 	String string `mapstructure:"string"`
 	Num    int    `mapstructure:"num"`
@@ -447,3 +459,13 @@ func TestStructWithEmbeddedUnmarshaling(t *testing.T) {
 	assert.Equal(t, "foo", tc.String)
 	assert.Equal(t, 123, tc.Num)
 }
+
+func TestDataTypeFromSignal(t *testing.T) {
+	dt, ok := DataTypeFromSignal("logs")
+	assert.Equal(t, ok, true)
+	assert.Equal(t, DataTypeLogs, dt)
+
+	dt, ok = DataTypeFromSignal("asdf")
+	assert.Equal(t, ok, false)
+	assert.Equal(t, DataType(""), dt)
+}

component/identifiable.go

@@ -13,9 +13,10 @@ import (
 const typeAndNameSeparator = "/"
 
 // ID represents the identity for a component. It combines two values:
-// * type - the Type of the component.
-// * name - the name of that component.
-// The component ID (combination type + name) is unique for a given component.Kind.
+// * typeVal - the Type of the component.
+// * nameVal - the name of that component.  This is optional and can be an empty string.
+// The Component ID (combination type + name) is unique for a given component.Kind.
+// Component IDs are defined in configuration by type[/name] - for examples [traces/1] or [oltp/blah]
 type ID struct {
 	typeVal Type   `mapstructure:"-"`
 	nameVal string `mapstructure:"-"`
@@ -88,6 +89,7 @@ func (id *ID) UnmarshalText(text []byte) error {
 	if id.typeVal, err = NewType(typeStr); err != nil {
 		return fmt.Errorf("in %q id: %w", idStr, err)
 	}
+
 	id.nameVal = nameStr
 
 	return nil

otelcol/otelcoltest/config_test.go

@@ -55,7 +55,7 @@ func TestLoadConfig(t *testing.T) {
 			Processors: []component.ID{component.MustNewID("nop")},
 			Exporters:  []component.ID{component.MustNewID("nop")},
 		},
-		cfg.Service.Pipelines[component.MustNewID("traces")],
+		cfg.Service.Pipelines[component.NewID(component.DataTypeTraces)],
 		"Did not load pipeline config correctly")
 }
 

service/config_test.go

@@ -59,7 +59,7 @@ func TestConfigValidate(t *testing.T) {
 				}
 				return cfg
 			},
-			expected: fmt.Errorf(`service::pipelines config validation failed: %w`, errors.New(`pipeline "wrongtype": unknown datatype "wrongtype"`)),
+			expected: fmt.Errorf(`service::pipelines config validation failed: %w`, errors.New(`pipeline "wrongtype": is not a DataType "wrongtype"`)),
 		},
 		{
 			name: "invalid-telemetry-metric-config",

service/internal/graph/graph.go

@@ -132,14 +132,14 @@ func (g *Graph) createNodes(set Settings) error {
 			// The presence of each key indicates how the connector is used as an exporter.
 			// The value is initially set to false. Later we will set the value to true *if* we
 			// confirm that there is a supported corresponding use as a receiver.
-			expTypes[pipelineID.Type()] = false
+			expTypes[pipelineID.Type().(component.DataType)] = false
 		}
 		recTypes := make(map[component.DataType]bool)
 		for _, pipelineID := range connectorsAsReceiver[connID] {
 			// The presence of each key indicates how the connector is used as a receiver.
 			// The value is initially set to false. Later we will set the value to true *if* we
 			// confirm that there is a supported corresponding use as an exporter.
-			recTypes[pipelineID.Type()] = false
+			recTypes[pipelineID.Type().(component.DataType)] = false
 		}
 
 		for expType := range expTypes {
@@ -182,7 +182,7 @@ func (g *Graph) createNodes(set Settings) error {
 }
 
 func (g *Graph) createReceiver(pipelineID, recvID component.ID) *receiverNode {
-	rcvrNode := newReceiverNode(pipelineID.Type(), recvID)
+	rcvrNode := newReceiverNode(pipelineID.Type().(component.DataType), recvID)
 	if node := g.componentGraph.Node(rcvrNode.ID()); node != nil {
 		g.instanceIDs[node.ID()].PipelineIDs[pipelineID] = struct{}{}
 		return node.(*receiverNode)
@@ -212,7 +212,7 @@ func (g *Graph) createProcessor(pipelineID, procID component.ID) *processorNode
 }
 
 func (g *Graph) createExporter(pipelineID, exprID component.ID) *exporterNode {
-	expNode := newExporterNode(pipelineID.Type(), exprID)
+	expNode := newExporterNode(pipelineID.Type().(component.DataType), exprID)
 	if node := g.componentGraph.Node(expNode.ID()); node != nil {
 		g.instanceIDs[expNode.ID()].PipelineIDs[pipelineID] = struct{}{}
 		return node.(*exporterNode)
@@ -229,7 +229,7 @@ func (g *Graph) createExporter(pipelineID, exprID component.ID) *exporterNode {
 }
 
 func (g *Graph) createConnector(exprPipelineID, rcvrPipelineID, connID component.ID) *connectorNode {
-	connNode := newConnectorNode(exprPipelineID.Type(), rcvrPipelineID.Type(), connID)
+	connNode := newConnectorNode(exprPipelineID.Type().(component.DataType), rcvrPipelineID.Type().(component.DataType), connID)
 	if node := g.componentGraph.Node(connNode.ID()); node != nil {
 		instanceID := g.instanceIDs[connNode.ID()]
 		instanceID.PipelineIDs[exprPipelineID] = struct{}{}

service/internal/graph/graph_test.go

@@ -2399,7 +2399,7 @@ func expectedInstances(m pipelines.Config, pID component.ID) (int, int) {
 		}
 
 		// This is a connector. Count the pipeline types where it is an exporter.
-		typeMap := map[component.DataType]bool{}
+		typeMap := map[component.Type]bool{}
 		for pID, pCfg := range m {
 			for _, eID := range pCfg.Exporters {
 				if eID == rID {
@@ -2416,7 +2416,7 @@ func expectedInstances(m pipelines.Config, pID component.ID) (int, int) {
 		}
 
 		// This is a connector. Count the pipeline types where it is a receiver.
-		typeMap := map[component.DataType]bool{}
+		typeMap := map[component.Type]bool{}
 		for pID, pCfg := range m {
 			for _, rID := range pCfg.Receivers {
 				if rID == eID {

service/pipelines/config.go

@@ -28,8 +28,13 @@ func (cfg Config) Validate() error {
 	// Check that all pipelines have at least one receiver and one exporter, and they reference
 	// only configured components.
 	for pipelineID, pipeline := range cfg {
-		if pipelineID.Type() != component.DataTypeTraces && pipelineID.Type() != component.DataTypeMetrics && pipelineID.Type() != component.DataTypeLogs {
-			return fmt.Errorf("pipeline %q: unknown datatype %q", pipelineID, pipelineID.Type())
+		dt, ok := pipelineID.Type().(component.DataType)
+		if !ok {
+			return fmt.Errorf("pipeline %q: is not a DataType %q", pipelineID, pipelineID.Type())
+		}
+		// This check should never really be necessary since the parsing logic should never create an unknown DataType - but there are no enums in go so this is might be good practice.
+		if _, ok := component.DataTypeFromSignal(string(dt)); !ok {
+			return fmt.Errorf("pipeline %q: unknown DataType %q", pipelineID, dt)
 		}
 
 		// Validate pipeline has at least one receiver.

service/pipelines/config_test.go

@@ -70,7 +70,20 @@ func TestConfigValidate(t *testing.T) {
 				}
 				return cfg
 			},
-			expected: errors.New(`pipeline "wrongtype": unknown datatype "wrongtype"`),
+			expected: errors.New(`pipeline "wrongtype": is not a DataType "wrongtype"`),
+		},
+		{
+			name: "unknown-service-pipeline-type",
+			cfgFn: func() Config {
+				cfg := generateConfig()
+				cfg[component.NewIDWithName(component.DataType("asdf"), "")] = &PipelineConfig{
+					Receivers:  []component.ID{component.MustNewID("nop")},
+					Processors: []component.ID{component.MustNewID("nop")},
+					Exporters:  []component.ID{component.MustNewID("nop")},
+				}
+				return cfg
+			},
+			expected: errors.New(`pipeline "asdf": unknown DataType "asdf"`),
 		},
 	}