Use yaml instead of JSON

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

Author: pavolloffay

cmd/mdatagen/internal/samplereceiver/generated_component_test.go

@@ -0,0 +1,83 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+title: sample receiver configuration
+type: object
+properties:
+    api_key:
+        description: APIKey is a secret API key (opaque string).
+        type: string
+    batch_size:
+        description: BatchSize is the number of items to send in each batch.
+        type: integer
+    custom_string:
+        description: CustomString is a custom string.
+        type: string
+    enabled:
+        description: Enabled controls whether the exporter is active.
+        type: boolean
+    endpoint:
+        description: Endpoint is the target URL to send data to.
+        type: string
+    endpoints:
+        description: Endpoints is a list of endpoint configurations.
+        type: array
+        items:
+            type: object
+            properties:
+                priority:
+                    description: Priority is the endpoint priority.
+                    type: integer
+                url:
+                    description: URL is the endpoint URL.
+                    type: string
+    headers:
+        description: Headers are additional headers to include in requests.
+        type: object
+        additionalProperties:
+            type: string
+    host:
+        description: Host is the network host.
+        type: string
+    id:
+        description: ID is the component identifier.
+        type: string
+    optional_retry:
+        description: OptionalRetry is an optional retry configuration.
+        type: object
+        properties:
+            initial_interval:
+                description: InitialInterval is the initial retry interval.
+                type: string
+                pattern: ^(0|[-+]?((\d+(\.\d*)?|\.\d+)(ns|us|µs|μs|ms|s|m|h))+)$
+            max_retries:
+                description: MaxRetries is the maximum number of retries.
+                type: integer
+    port:
+        description: Port is the network port.
+        type: integer
+    retry:
+        description: Retry contains retry configuration.
+        type: object
+        properties:
+            initial_interval:
+                description: InitialInterval is the initial retry interval.
+                type: string
+                pattern: ^(0|[-+]?((\d+(\.\d*)?|\.\d+)(ns|us|µs|μs|ms|s|m|h))+)$
+            max_retries:
+                description: MaxRetries is the maximum number of retries.
+                type: integer
+    secrets:
+        description: Secrets is a list of secret key-value pairs.
+        type: object
+    start_time:
+        description: StartTime is the time when the receiver should start collecting data.
+        type: string
+        format: date-time
+    tags:
+        description: Tags are optional tags to attach.
+        type: array
+        items:
+            type: string
+    timeout:
+        description: Timeout is the maximum time to wait for a response.
+        type: string
+        pattern: ^(0|[-+]?((\d+(\.\d*)?|\.\d+)(ns|us|µs|μs|ms|s|m|h))+)$

cmd/mdatagen/internal/samplereceiver/generated_package_test.go

@@ -3,7 +3,7 @@
 
 package internal // import "go.opentelemetry.io/collector/cmd/mdatagen/internal"
 
-// SchemaConfig holds configuration for JSON schema generation.
+// SchemaConfig holds configuration for YAML schema generation.
 type SchemaConfig struct {
 	// Enabled controls whether schema generation is enabled (default: false).
 	Enabled bool `mapstructure:"enabled"`

cmd/mdatagen/internal/samplereceiver/internal/metadata/schemas/config_schema.json

@@ -4,12 +4,13 @@
 package schemagen // import "go.opentelemetry.io/collector/cmd/mdatagen/internal/schemagen"
 
 import (
-	"encoding/json"
 	"fmt"
 	"maps"
 	"os"
 	"path/filepath"
 	"strings"
+
+	"gopkg.in/yaml.v3"
 )
 
 const (
@@ -37,7 +38,7 @@ func NewSchemaGenerator(outputDir string, analyzer *PackageAnalyzer) *SchemaGene
 	}
 }
 
-// GenerateSchema generates a JSON schema for the component's config.
+// 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)
 	if err != nil {
@@ -52,15 +53,12 @@ func (g *SchemaGenerator) GenerateSchema(componentKind, componentName, configTyp
 	}
 
 	// Write schema to file
-	outputPath := filepath.Join(g.outputDir, "config_schema.json")
-	data, err := json.MarshalIndent(schema, "", "  ")
+	outputPath := filepath.Join(g.outputDir, "config_schema.yaml")
+	data, err := yaml.Marshal(schema)
 	if err != nil {
 		return fmt.Errorf("failed to marshal schema: %w", err)
 	}
 
-	// Add trailing newline
-	data = append(data, '\n')
-
 	if err := os.WriteFile(outputPath, data, 0o600); err != nil {
 		return fmt.Errorf("failed to write schema: %w", err)
 	}

cmd/mdatagen/internal/samplereceiver/internal/metadata/schemas/config_schema.yaml

@@ -27,7 +27,7 @@ func TestSchemaGenerator_GenerateSchema(t *testing.T) {
 	require.NoError(t, err)
 
 	// Check that schema file was created
-	schemaPath := filepath.Join(outputDir, "config_schema.json")
+	schemaPath := filepath.Join(outputDir, "config_schema.yaml")
 	_, err = os.Stat(schemaPath)
 	require.NoError(t, err, "schema file was not created")
 
@@ -36,12 +36,21 @@ func TestSchemaGenerator_GenerateSchema(t *testing.T) {
 	require.NoError(t, err)
 
 	// Read the expected schema from testdata
-	expectedPath := filepath.Join("testdata", "config_schema.json")
+	expectedPath := filepath.Join("testdata", "config_schema.yaml")
 	expectedData, err := os.ReadFile(expectedPath) //#nosec G304 -- test file path
 	require.NoError(t, err)
 
-	// Compare JSON content (ignoring formatting differences)
-	assert.JSONEq(t, string(expectedData), string(generatedData))
+	// Compare YAML content by parsing both and comparing as JSON
+	var generatedSchema, expectedSchema any
+	require.NoError(t, yaml.Unmarshal(generatedData, &generatedSchema))
+	require.NoError(t, yaml.Unmarshal(expectedData, &expectedSchema))
+
+	generatedJSON, err := json.Marshal(generatedSchema)
+	require.NoError(t, err)
+	expectedJSON, err := json.Marshal(expectedSchema)
+	require.NoError(t, err)
+
+	assert.JSONEq(t, string(expectedJSON), string(generatedJSON))
 }
 
 func TestParseTag(t *testing.T) {
@@ -138,14 +147,20 @@ func TestSetSchemaType(t *testing.T) {
 }
 
 func TestSchemaValidation(t *testing.T) {
-	// Load the JSON schema
-	schemaPath := filepath.Join("testdata", "config_schema.json")
+	// Load the YAML schema
+	schemaPath := filepath.Join("testdata", "config_schema.yaml")
 	schemaData, err := os.ReadFile(schemaPath)
 	require.NoError(t, err, "failed to read schema file")
 
-	// Parse the schema JSON
+	// Parse the schema YAML and convert to JSON-compatible format
 	var schemaDoc any
-	err = json.Unmarshal(schemaData, &schemaDoc)
+	err = yaml.Unmarshal(schemaData, &schemaDoc)
+	require.NoError(t, err, "failed to parse schema YAML")
+
+	// Convert to JSON and back to ensure JSON-compatible types
+	jsonBytes, err := json.Marshal(schemaDoc)
+	require.NoError(t, err, "failed to convert schema to JSON")
+	err = json.Unmarshal(jsonBytes, &schemaDoc)
 	require.NoError(t, err, "failed to parse schema JSON")
 
 	// Compile the schema