[component] Add MustNewType constructor for component.Type (#9414)

**Description:** 

- Adds `component.MustNewType` to create a type. This function panics if
the type has invalid characters. Add similar functions
`component.MustNewID` and `component.MustNewIDWithName`.
- Adds `component.Type.String` to recover the string
- Use `component.MustNewType`, `component.MustNewID`,
`component.MustNewIDWithName` and `component.Type.String` everywhere in
this codebase. To do this I changed `component.Type` into an opaque
struct and checked for compile-time errors.

Some notes:

1. All components currently on core and contrib follow this rule. This
is still breaking for other components.
2. A future PR will change this into a struct, to actually validate this
(right now you can just do `component.Type("anything")` to bypass
validation). I want to do this in two steps to avoid breaking contrib
tests: we first introduce this function, and after that we change into a
struct.

**Link to tracking Issue:** Updates #9208

.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

@@ -365,8 +365,11 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
+var (
+	Type = component.MustNewType("foo")
+)
+
 const (
-	Type             = "foo"
 	MetricsStability = component.StabilityLevelBeta
 )
 
@@ -399,8 +402,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 }}")
-}
+}

cmd/mdatagen/validate.go

@@ -6,6 +6,7 @@ package main
 import (
 	"errors"
 	"fmt"
+	"regexp"
 
 	"go.uber.org/multierr"
 
@@ -29,10 +30,20 @@ func (md *metadata) Validate() error {
 	return errs
 }
 
+// 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 '_'.
+// This must be kept in sync with the regex in component/config.go.
+var typeRegexp = regexp.MustCompile(`^[a-zA-Z][0-9a-zA-Z_]*$`)
+
 func (md *metadata) validateType() error {
 	if md.Type == "" {
 		return errors.New("missing type")
 	}
+
+	if !typeRegexp.MatchString(md.Type) {
+		return fmt.Errorf("invalid character(s) in type %q", md.Type)
+	}
 	return nil
 }
 

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,45 @@ func callValidateIfPossible(v reflect.Value) error {
 // Type is the component type as it is used in the config.
 type Type string
 
+// 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 '_'.
+// This must be kept in sync with the regex in cmd/mdatagen/validate.go.
+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 %q", ty)
+	}
+	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