[component] Add MustNewType constructor for component.Type

.chloggen/mx-psi_component-type-validation.yaml

@@ -0,0 +1,26 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: breaking
+
+# 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: Validate component.Type at creation and unmarshaling time.
+
+# One or more tracking issues or pull requests related to the change
+issues: [9208]
+
+# (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: |
+  - A component.Type must start with an ASCII alphabetic character and can only contain ASCII alphanumeric characters and '_'.
+
+# 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]

cmd/mdatagen/main_test.go

@@ -328,8 +328,11 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
+var (
+	Type = component.MustNewType("foo")
+)
+
 const (
-	Type             = "foo"
 	MetricsStability = component.StabilityLevelBeta
 )
 
@@ -362,8 +365,11 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
+var (
+	Type = component.MustNewType("foo")
+)
+
 const (
-	Type             = "foo"
 	MetricsStability = component.StabilityLevelAlpha
 )
 

cmd/mdatagen/templates/status.go.tmpl

@@ -8,8 +8,11 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
+var (
+	Type = component.MustNewType("{{ .Type }}")
+)
+
 const (
-	Type = "{{ .Type }}"
 	{{- range $stability, $signals := .Status.Stability }}
 	{{- range $signal := $signals }}
 	{{ toCamelCase $signal }}Stability = component.StabilityLevel{{ casesTitle $stability }}
@@ -23,4 +26,4 @@ func Meter(settings component.TelemetrySettings) metric.Meter {
 
 func Tracer(settings component.TelemetrySettings) trace.Tracer {
 	return settings.TracerProvider.Tracer("{{ .ScopeName }}")
-}
+}

component/componenttest/nop_host_test.go

@@ -21,5 +21,5 @@ func TestNewNopHost(t *testing.T) {
 	nh.ReportFatalError(errors.New("TestError"))
 	assert.Nil(t, nh.GetExporters()) // nolint: staticcheck
 	assert.Nil(t, nh.GetExtensions())
-	assert.Nil(t, nh.GetFactory(component.KindReceiver, "test"))
+	assert.Nil(t, nh.GetFactory(component.KindReceiver, component.MustNewType("test")))
 }

component/componenttest/otelprometheuschecker_test.go

@@ -36,10 +36,10 @@ func TestPromChecker(t *testing.T) {
 	pc, err := newStubPromChecker()
 	require.NoError(t, err)
 
-	scraper := component.NewID("fakeScraper")
-	receiver := component.NewID("fakeReceiver")
-	processor := component.NewID("fakeProcessor")
-	exporter := component.NewID("fakeExporter")
+	scraper := component.MustNewID("fakeScraper")
+	receiver := component.MustNewID("fakeReceiver")
+	processor := component.MustNewID("fakeProcessor")
+	exporter := component.MustNewID("fakeExporter")
 	transport := "fakeTransport"
 
 	assert.NoError(t,

component/config.go

@@ -4,7 +4,9 @@
 package component // import "go.opentelemetry.io/collector/component"
 
 import (
+	"fmt"
 	"reflect"
+	"regexp"
 
 	"go.uber.org/multierr"
 
@@ -110,6 +112,46 @@
 // Type is the component type as it is used in the config.
 type Type string
 
+var _ fmt.Stringer = (Type)("")
+
+// String returns the string representation of the type.
+func (t Type) String() string {
+	return string(t)
+}
+
+// typeRegexp is used to validate the type of a component.
+// A type must start with an ASCII alphabetic character and
+// can only contain ASCII alphanumeric characters and '_'.
+var typeRegexp = regexp.MustCompile(`^[a-zA-Z][0-9a-zA-Z_]*$`)
+
+// newType creates a type. It returns an error if the type is invalid.
+// A type must
+// - have at least one character,
+// - start with an ASCII alphabetic character and
+// - can only contain ASCII alphanumeric characters and '_'.
+func newType(ty string) (Type, error) {
+	if len(ty) == 0 {
+		return Type(""), fmt.Errorf("id must not be empty")
+	}
+	if !typeRegexp.MatchString(ty) {
+		return Type(""), fmt.Errorf("invalid character(s) in type")
+	}
+	return Type(ty), nil
+}
+
+// MustNewType creates a type. It panics if the type is invalid.
+// A type must
+// - have at least one character,
+// - start with an ASCII alphabetic character and
+// - can only contain ASCII alphanumeric characters and '_'.
+func MustNewType(strType string) Type {
+	ty, err := newType(strType)
+	if err != nil {
+		panic(err)
+	}
+	return ty
+}
+
 // 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

component/config_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type configChildStruct struct {
@@ -194,3 +195,222 @@ func TestValidateConfig(t *testing.T) {
 		})
 	}
 }
+
+func TestNewType(t *testing.T) {
+	tests := []struct {
+		name      string
+		shouldErr bool
+	}{
+		{name: "active_directory_ds"},
+		{name: "aerospike"},
+		{name: "alertmanager"},
+		{name: "alibabacloud_logservice"},
+		{name: "apache"},
+		{name: "apachespark"},
+		{name: "asapclient"},
+		{name: "attributes"},
+		{name: "awscloudwatch"},
+		{name: "awscloudwatchlogs"},
+		{name: "awscloudwatchmetrics"},
+		{name: "awscontainerinsightreceiver"},
+		{name: "awsecscontainermetrics"},
+		{name: "awsemf"},
+		{name: "awsfirehose"},
+		{name: "awskinesis"},
+		{name: "awsproxy"},
+		{name: "awss3"},
+		{name: "awsxray"},
+		{name: "azureblob"},
+		{name: "azuredataexplorer"},
+		{name: "azureeventhub"},
+		{name: "azuremonitor"},
+		{name: "basicauth"},
+		{name: "batch"},
+		{name: "bearertokenauth"},
+		{name: "bigip"},
+		{name: "carbon"},
+		{name: "cassandra"},
+		{name: "chrony"},
+		{name: "clickhouse"},
+		{name: "cloudflare"},
+		{name: "cloudfoundry"},
+		{name: "collectd"},
+		{name: "configschema"},
+		{name: "coralogix"},
+		{name: "couchdb"},
+		{name: "count"},
+		{name: "cumulativetodelta"},
+		{name: "datadog"},
+		{name: "dataset"},
+		{name: "db_storage"},
+		{name: "debug"},
+		{name: "deltatorate"},
+		{name: "demo"},
+		{name: "docker_observer"},
+		{name: "docker_stats"},
+		{name: "dynatrace"},
+		{name: "ecs_observer"},
+		{name: "ecs_task_observer"},
+		{name: "elasticsearch"},
+		{name: "exceptions"},
+		{name: "experimental_metricsgeneration"},
+		{name: "expvar"},
+		{name: "f5cloud"},
+		{name: "failover"},
+		{name: "file"},
+		{name: "filelog"},
+		{name: "filestats"},
+		{name: "file_storage"},
+		{name: "filter"},
+		{name: "flinkmetrics"},
+		{name: "fluentforward"},
+		{name: "forward"},
+		{name: "githubgen"},
+		{name: "gitprovider"},
+		{name: "golden"},
+		{name: "googlecloud"},
+		{name: "googlecloudpubsub"},
+		{name: "googlecloudspanner"},
+		{name: "googlemanagedprometheus"},
+		{name: "groupbyattrs"},
+		{name: "groupbytrace"},
+		{name: "haproxy"},
+		{name: "headers_setter"},
+		{name: "health_check"},
+		{name: "honeycombmarker"},
+		{name: "hostmetrics"},
+		{name: "host_observer"},
+		{name: "httpcheck"},
+		{name: "http_forwarder"},
+		{name: "iis"},
+		{name: "influxdb"},
+		{name: "instana"},
+		{name: "interval"},
+		{name: "jaeger"},
+		{name: "jaeger_encoding"},
+		{name: "jaegerremotesampling"},
+		{name: "jmx"},
+		{name: "journald"},
+		{name: "json_log_encoding"},
+		{name: "k8sattributes"},
+		{name: "k8s_cluster"},
+		{name: "k8s_events"},
+		{name: "k8sobjects"},
+		{name: "k8s_observer"},
+		{name: "kafka"},
+		{name: "kafkametrics"},
+		{name: "kinetica"},
+		{name: "kubeletstats"},
+		{name: "loadbalancing"},
+		{name: "logging"},
+		{name: "logicmonitor"},
+		{name: "logstransform"},
+		{name: "logzio"},
+		{name: "loki"},
+		{name: "mdatagen"},
+		{name: "memcached"},
+		{name: "memory_ballast"},
+		{name: "memory_limiter"},
+		{name: "metricstransform"},
+		{name: "mezmo"},
+		{name: "mongodb"},
+		{name: "mongodbatlas"},
+		{name: "mysql"},
+		{name: "namedpipe"},
+		{name: "nginx"},
+		{name: "nsxt"},
+		{name: "oauth2client"},
+		{name: "oidc"},
+		{name: "opamp"},
+		{name: "opampsupervisor"},
+		{name: "opencensus"},
+		{name: "opensearch"},
+		{name: "oracledb"},
+		{name: "osquery"},
+		{name: "otelarrow"},
+		{name: "otelcontribcol"},
+		{name: "oteltestbedcol"},
+		{name: "otlp"},
+		{name: "otlp_encoding"},
+		{name: "otlphttp"},
+		{name: "otlpjsonfile"},
+		{name: "ottl"},
+		{name: "podman_stats"},
+		{name: "postgresql"},
+		{name: "pprof"},
+		{name: "probabilistic_sampler"},
+		{name: "prometheus"},
+		{name: "prometheusremotewrite"},
+		{name: "prometheus_simple"},
+		{name: "pulsar"},
+		{name: "purefa"},
+		{name: "purefb"},
+		{name: "rabbitmq"},
+		{name: "receiver_creator"},
+		{name: "redaction"},
+		{name: "redis"},
+		{name: "remotetap"},
+		{name: "resource"},
+		{name: "resourcedetection"},
+		{name: "riak"},
+		{name: "routing"},
+		{name: "saphana"},
+		{name: "sapm"},
+		{name: "schema"},
+		{name: "sentry"},
+		{name: "servicegraph"},
+		{name: "signalfx"},
+		{name: "sigv4auth"},
+		{name: "skywalking"},
+		{name: "snmp"},
+		{name: "snowflake"},
+		{name: "solace"},
+		{name: "solarwindsapmsettings"},
+		{name: "span"},
+		{name: "spanmetrics"},
+		{name: "splunkenterprise"},
+		{name: "splunk_hec"},
+		{name: "sqlquery"},
+		{name: "sqlserver"},
+		{name: "sshcheck"},
+		{name: "statsd"},
+		{name: "sumologic"},
+		{name: "syslog"},
+		{name: "tail_sampling"},
+		{name: "tcplog"},
+		{name: "telemetrygen"},
+		{name: "tencentcloud_logservice"},
+		{name: "text_encoding"},
+		{name: "transform"},
+		{name: "udplog"},
+		{name: "vcenter"},
+		{name: "wavefront"},
+		{name: "webhookevent"},
+		{name: "windowseventlog"},
+		{name: "windowsperfcounters"},
+		{name: "zipkin"},
+		{name: "zipkin_encoding"},
+		{name: "zookeeper"},
+		{name: "zpages"},
+
+		{name: "", shouldErr: true},
+		{name: "contains spaces", shouldErr: true},
+		{name: "contains-dashes", shouldErr: true},
+		{name: "0startswithnumber", shouldErr: true},
+		{name: "contains/slash", shouldErr: true},
+		{name: "contains:colon", shouldErr: true},
+		{name: "contains#hash", shouldErr: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ty, err := newType(tt.name)
+			if tt.shouldErr {
+				assert.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.name, ty.String())
+			}
+		})
+	}
+}