Handle non standard config objects

Signed-off-by: Pavol Loffay <[email protected]>

Author: pavolloffay

cmd/mdatagen/internal/command.go

@@ -500,10 +500,41 @@ func generateSchema(md Metadata, ymlDir string) error {
 		return fmt.Errorf("failed to create schemas directory: %w", err)
 	}
 
+	// Parse config type specification
+	pkgPath, typeName := parseConfigType(md.Schema.ConfigType)
+
 	// Create analyzer and generator
 	analyzer := schemagen.NewPackageAnalyzer(ymlDir)
 	generator := schemagen.NewSchemaGenerator(outputDir, analyzer)
 
-	// Generate schema (config type is auto-detected)
-	return generator.GenerateSchema(md.Status.Class, md.Type, "")
+	// Generate schema
+	return generator.GenerateSchema(md.Status.Class, md.Type, typeName, pkgPath)
+}
+
+// parseConfigType parses a config type specification into package path and type name.
+// Examples:
+//   - "Config" -> ("", "Config")
+//   - "go.opentelemetry.io/collector/pkg.Config" -> ("go.opentelemetry.io/collector/pkg", "Config")
+func parseConfigType(configType string) (pkgPath, typeName string) {
+	if configType == "" {
+		return "", ""
+	}
+
+	// Find the last dot that separates package path from type name
+	lastDot := strings.LastIndex(configType, ".")
+	if lastDot == -1 {
+		// No dot means it's just a type name in the local package
+		return "", configType
+	}
+
+	// Check if this looks like a package path (contains "/" before the last dot)
+	potentialPkg := configType[:lastDot]
+	if strings.Contains(potentialPkg, "/") {
+		// It's a fully qualified type: pkg/path.TypeName
+		return potentialPkg, configType[lastDot+1:]
+	}
+
+	// No slash means it's just a type name (e.g., "Config" or possibly "pkg.Config" for local)
+	// Treat as local type name
+	return "", configType
 }

cmd/mdatagen/internal/schema.go

@@ -7,4 +7,10 @@ package internal // import "go.opentelemetry.io/collector/cmd/mdatagen/internal"
 type SchemaConfig struct {
 	// Enabled controls whether schema generation is enabled (default: false).
 	Enabled bool `mapstructure:"enabled"`
+
+	// ConfigType specifies the config type to generate schema for.
+	// Can be a simple type name (e.g., "Config") for local package,
+	// or a fully qualified type (e.g., "go.opentelemetry.io/collector/pkg.Config")
+	// for external packages. If empty, auto-detection is used.
+	ConfigType string `mapstructure:"config_type"`
 }

cmd/mdatagen/internal/schemagen/analyzer.go

@@ -29,8 +29,9 @@ func NewPackageAnalyzer(dir string) *PackageAnalyzer {
 }
 
 // analyzeConfig loads the package and finds the Config struct.
-// If configTypeName is empty, it auto-detects by looking for component.Config implementation.
-func (a *PackageAnalyzer) analyzeConfig(configTypeName string) (*StructInfo, error) {
+// configTypeName is the name of the config type (e.g., "Config"). If empty, auto-detection is used.
+// configPkgPath is the package path where the config is defined. If empty, the local package is used.
+func (a *PackageAnalyzer) analyzeConfig(configTypeName, configPkgPath string) (*StructInfo, error) {
 	cfg := &packages.Config{
 		Mode: packages.NeedName | packages.NeedTypes | packages.NeedTypesInfo |
 			packages.NeedSyntax | packages.NeedImports | packages.NeedDeps,
@@ -58,16 +59,26 @@ func (a *PackageAnalyzer) analyzeConfig(configTypeName string) (*StructInfo, err
 
 	// Auto-detect config type if not specified
 	if configTypeName == "" {
-		configTypeName = a.detectConfigType(pkg)
+		configTypeName = a.detectConfigFromVarDecl(pkg)
 		if configTypeName == "" {
 			configTypeName = "Config" // fallback to default
 		}
 	}
 
+	// Determine which package to analyze
+	analyzePkg := pkg
+	if configPkgPath != "" {
+		// Config is in an external package
+		analyzePkg, err = a.loadPackage(configPkgPath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to load config package %s: %w", configPkgPath, err)
+		}
+	}
+
 	// Find the Config type
-	obj := pkg.Types.Scope().Lookup(configTypeName)
+	obj := analyzePkg.Types.Scope().Lookup(configTypeName)
 	if obj == nil {
-		return nil, fmt.Errorf("type %s not found in package %s", configTypeName, pkg.PkgPath)
+		return nil, fmt.Errorf("type %s not found in package %s", configTypeName, analyzePkg.PkgPath)
 	}
 
 	named, ok := obj.Type().(*types.Named)
@@ -81,11 +92,11 @@ func (a *PackageAnalyzer) analyzeConfig(configTypeName string) (*StructInfo, err
 	}
 
 	// Extract fields
-	fields := a.extractFields(pkg, structType)
+	fields := a.extractFields(analyzePkg, structType)
 
 	return &StructInfo{
 		Name:    configTypeName,
-		Package: pkg.PkgPath,
+		Package: analyzePkg.PkgPath,
 		Fields:  fields,
 	}, nil
 }
@@ -260,9 +271,9 @@ func parseTag(tag string) (name string, squash bool) {
 	return "", false
 }
 
-// detectConfigType looks for the component.Config interface assignment pattern:
+// detectConfigFromVarDecl looks for the component.Config interface assignment pattern:
 // var _ component.Config = (*TypeName)(nil)
-func (a *PackageAnalyzer) detectConfigType(pkg *packages.Package) string {
+func (a *PackageAnalyzer) detectConfigFromVarDecl(pkg *packages.Package) string {
 	for _, file := range pkg.Syntax {
 		for _, decl := range file.Decls {
 			genDecl, ok := decl.(*ast.GenDecl)

cmd/mdatagen/internal/schemagen/generator.go

@@ -39,8 +39,10 @@ func NewSchemaGenerator(outputDir string, analyzer *PackageAnalyzer) *SchemaGene
 }
 
 // GenerateSchema generates a YAML schema for the component's config.
-func (g *SchemaGenerator) GenerateSchema(componentKind, componentName, configTypeName string) error {
-	structInfo, err := g.analyzer.analyzeConfig(configTypeName)
+// configTypeName is the name of the config type (e.g., "Config").
+// configPkgPath is the package path where the config is defined (empty for local package).
+func (g *SchemaGenerator) GenerateSchema(componentKind, componentName, configTypeName, configPkgPath string) error {
+	structInfo, err := g.analyzer.analyzeConfig(configTypeName, configPkgPath)
 	if err != nil {
 		return fmt.Errorf("failed to analyze config: %w", err)
 	}

cmd/mdatagen/internal/schemagen/generator_test.go

@@ -22,8 +22,8 @@ func TestSchemaGenerator_GenerateSchema(t *testing.T) {
 	analyzer := NewPackageAnalyzer(testDir)
 	generator := NewSchemaGenerator(outputDir, analyzer)
 
-	// Pass empty string to test auto-detection of config type
-	err := generator.GenerateSchema("receiver", "sample", "")
+	// Pass empty strings to test auto-detection of config type
+	err := generator.GenerateSchema("receiver", "sample", "", "")
 	require.NoError(t, err)
 
 	// Check that schema file was created
@@ -53,6 +53,34 @@ func TestSchemaGenerator_GenerateSchema(t *testing.T) {
 	assert.JSONEq(t, string(expectedJSON), string(generatedJSON))
 }
 
+func TestDetectConfigFromFactory(t *testing.T) {
+	// Test detection from createDefaultConfig() function
+	// The samplereceiver uses var _ component.Config = (*Config)(nil) pattern,
+	// but we can test that the detection chain works correctly
+
+	testDir := filepath.Join("..", "samplereceiver")
+	analyzer := NewPackageAnalyzer(testDir)
+
+	// Load the package
+	structInfo, err := analyzer.analyzeConfig("", "")
+	require.NoError(t, err)
+
+	// Verify the config was detected (samplereceiver uses MyConfig)
+	assert.Equal(t, "MyConfig", structInfo.Name)
+	assert.Contains(t, structInfo.Package, "samplereceiver")
+
+	// Verify fields were extracted
+	assert.NotEmpty(t, structInfo.Fields)
+
+	// Check for known fields
+	fieldNames := make(map[string]bool)
+	for _, f := range structInfo.Fields {
+		fieldNames[f.JSONName] = true
+	}
+	assert.True(t, fieldNames["endpoint"], "expected 'endpoint' field")
+	assert.True(t, fieldNames["timeout"], "expected 'timeout' field")
+}
+
 func TestParseTag(t *testing.T) {
 	tests := []struct {
 		name           string