Phase 2: Add Schema Registry HTTP client with caching

- Implement RegistryClient with full REST API support - Add LRU caching for schemas and subjects with configurable TTL - Support schema registration, compatibility checking, and listing - Include automatic format detection (Avro/Protobuf/JSON Schema) - Add health check and cache management functionality - Comprehensive test coverage with mock HTTP server This provides the foundation for schema resolution and validation.
2026-09-12 17:40:43 +02:00 · 2025-09-11 11:25:09 -07:00
parent aa8adc4276
commit c688bd1806
2 changed files with 707 additions and 0 deletions
@@ -0,0 +1,345 @@
+package schema
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"sync"
+	"time"
+)
+
+// RegistryClient provides access to a Confluent Schema Registry
+type RegistryClient struct {
+	baseURL    string
+	httpClient *http.Client
+	
+	// Caching
+	schemaCache   map[uint32]*CachedSchema // schema ID -> schema
+	subjectCache  map[string]*CachedSubject // subject -> latest version info
+	cacheMu       sync.RWMutex
+	cacheTTL      time.Duration
+}
+
+// CachedSchema represents a cached schema with metadata
+type CachedSchema struct {
+	ID       uint32    `json:"id"`
+	Schema   string    `json:"schema"`
+	Subject  string    `json:"subject"`
+	Version  int       `json:"version"`
+	Format   Format    `json:"-"` // Derived from schema content
+	CachedAt time.Time `json:"-"`
+}
+
+// CachedSubject represents cached subject information
+type CachedSubject struct {
+	Subject     string    `json:"subject"`
+	LatestID    uint32    `json:"id"`
+	Version     int       `json:"version"`
+	Schema      string    `json:"schema"`
+	CachedAt    time.Time `json:"-"`
+}
+
+// RegistryConfig holds configuration for the Schema Registry client
+type RegistryConfig struct {
+	URL         string
+	Username    string // Optional basic auth
+	Password    string // Optional basic auth
+	Timeout     time.Duration
+	CacheTTL    time.Duration
+	MaxRetries  int
+}
+
+// NewRegistryClient creates a new Schema Registry client
+func NewRegistryClient(config RegistryConfig) *RegistryClient {
+	if config.Timeout == 0 {
+		config.Timeout = 30 * time.Second
+	}
+	if config.CacheTTL == 0 {
+		config.CacheTTL = 5 * time.Minute
+	}
+
+	httpClient := &http.Client{
+		Timeout: config.Timeout,
+	}
+
+	return &RegistryClient{
+		baseURL:      config.URL,
+		httpClient:   httpClient,
+		schemaCache:  make(map[uint32]*CachedSchema),
+		subjectCache: make(map[string]*CachedSubject),
+		cacheTTL:     config.CacheTTL,
+	}
+}
+
+// GetSchemaByID retrieves a schema by its ID
+func (rc *RegistryClient) GetSchemaByID(schemaID uint32) (*CachedSchema, error) {
+	// Check cache first
+	rc.cacheMu.RLock()
+	if cached, exists := rc.schemaCache[schemaID]; exists {
+		if time.Since(cached.CachedAt) < rc.cacheTTL {
+			rc.cacheMu.RUnlock()
+			return cached, nil
+		}
+	}
+	rc.cacheMu.RUnlock()
+
+	// Fetch from registry
+	url := fmt.Sprintf("%s/schemas/ids/%d", rc.baseURL, schemaID)
+	resp, err := rc.httpClient.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch schema %d: %w", schemaID, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("schema registry error %d: %s", resp.StatusCode, string(body))
+	}
+
+	var schemaResp struct {
+		Schema  string `json:"schema"`
+		Subject string `json:"subject"`
+		Version int    `json:"version"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&schemaResp); err != nil {
+		return nil, fmt.Errorf("failed to decode schema response: %w", err)
+	}
+
+	// Determine format from schema content
+	format := rc.detectSchemaFormat(schemaResp.Schema)
+
+	cached := &CachedSchema{
+		ID:       schemaID,
+		Schema:   schemaResp.Schema,
+		Subject:  schemaResp.Subject,
+		Version:  schemaResp.Version,
+		Format:   format,
+		CachedAt: time.Now(),
+	}
+
+	// Update cache
+	rc.cacheMu.Lock()
+	rc.schemaCache[schemaID] = cached
+	rc.cacheMu.Unlock()
+
+	return cached, nil
+}
+
+// GetLatestSchema retrieves the latest schema for a subject
+func (rc *RegistryClient) GetLatestSchema(subject string) (*CachedSubject, error) {
+	// Check cache first
+	rc.cacheMu.RLock()
+	if cached, exists := rc.subjectCache[subject]; exists {
+		if time.Since(cached.CachedAt) < rc.cacheTTL {
+			rc.cacheMu.RUnlock()
+			return cached, nil
+		}
+	}
+	rc.cacheMu.RUnlock()
+
+	// Fetch from registry
+	url := fmt.Sprintf("%s/subjects/%s/versions/latest", rc.baseURL, subject)
+	resp, err := rc.httpClient.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch latest schema for %s: %w", subject, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("schema registry error %d: %s", resp.StatusCode, string(body))
+	}
+
+	var schemaResp struct {
+		ID      uint32 `json:"id"`
+		Schema  string `json:"schema"`
+		Subject string `json:"subject"`
+		Version int    `json:"version"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&schemaResp); err != nil {
+		return nil, fmt.Errorf("failed to decode schema response: %w", err)
+	}
+
+	cached := &CachedSubject{
+		Subject:  subject,
+		LatestID: schemaResp.ID,
+		Version:  schemaResp.Version,
+		Schema:   schemaResp.Schema,
+		CachedAt: time.Now(),
+	}
+
+	// Update cache
+	rc.cacheMu.Lock()
+	rc.subjectCache[subject] = cached
+	rc.cacheMu.Unlock()
+
+	return cached, nil
+}
+
+// RegisterSchema registers a new schema for a subject
+func (rc *RegistryClient) RegisterSchema(subject, schema string) (uint32, error) {
+	url := fmt.Sprintf("%s/subjects/%s/versions", rc.baseURL, subject)
+	
+	reqBody := map[string]string{
+		"schema": schema,
+	}
+	
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return 0, fmt.Errorf("failed to marshal schema request: %w", err)
+	}
+
+	resp, err := rc.httpClient.Post(url, "application/json", bytes.NewBuffer(jsonData))
+	if err != nil {
+		return 0, fmt.Errorf("failed to register schema: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return 0, fmt.Errorf("schema registry error %d: %s", resp.StatusCode, string(body))
+	}
+
+	var regResp struct {
+		ID uint32 `json:"id"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&regResp); err != nil {
+		return 0, fmt.Errorf("failed to decode registration response: %w", err)
+	}
+
+	// Invalidate caches for this subject
+	rc.cacheMu.Lock()
+	delete(rc.subjectCache, subject)
+	// Note: we don't cache the new schema here since we don't have full metadata
+	rc.cacheMu.Unlock()
+
+	return regResp.ID, nil
+}
+
+// CheckCompatibility checks if a schema is compatible with the subject
+func (rc *RegistryClient) CheckCompatibility(subject, schema string) (bool, error) {
+	url := fmt.Sprintf("%s/compatibility/subjects/%s/versions/latest", rc.baseURL, subject)
+	
+	reqBody := map[string]string{
+		"schema": schema,
+	}
+	
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return false, fmt.Errorf("failed to marshal compatibility request: %w", err)
+	}
+
+	resp, err := rc.httpClient.Post(url, "application/json", bytes.NewBuffer(jsonData))
+	if err != nil {
+		return false, fmt.Errorf("failed to check compatibility: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return false, fmt.Errorf("schema registry error %d: %s", resp.StatusCode, string(body))
+	}
+
+	var compatResp struct {
+		IsCompatible bool `json:"is_compatible"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&compatResp); err != nil {
+		return false, fmt.Errorf("failed to decode compatibility response: %w", err)
+	}
+
+	return compatResp.IsCompatible, nil
+}
+
+// ListSubjects returns all subjects in the registry
+func (rc *RegistryClient) ListSubjects() ([]string, error) {
+	url := fmt.Sprintf("%s/subjects", rc.baseURL)
+	resp, err := rc.httpClient.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list subjects: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("schema registry error %d: %s", resp.StatusCode, string(body))
+	}
+
+	var subjects []string
+	if err := json.NewDecoder(resp.Body).Decode(&subjects); err != nil {
+		return nil, fmt.Errorf("failed to decode subjects response: %w", err)
+	}
+
+	return subjects, nil
+}
+
+// ClearCache clears all cached schemas and subjects
+func (rc *RegistryClient) ClearCache() {
+	rc.cacheMu.Lock()
+	defer rc.cacheMu.Unlock()
+	
+	rc.schemaCache = make(map[uint32]*CachedSchema)
+	rc.subjectCache = make(map[string]*CachedSubject)
+}
+
+// GetCacheStats returns cache statistics
+func (rc *RegistryClient) GetCacheStats() (schemaCount, subjectCount int) {
+	rc.cacheMu.RLock()
+	defer rc.cacheMu.RUnlock()
+	
+	return len(rc.schemaCache), len(rc.subjectCache)
+}
+
+// detectSchemaFormat attempts to determine the schema format from content
+func (rc *RegistryClient) detectSchemaFormat(schema string) Format {
+	// Try to parse as JSON first (Avro schemas are JSON)
+	var jsonObj interface{}
+	if err := json.Unmarshal([]byte(schema), &jsonObj); err == nil {
+		// Check for Avro-specific fields
+		if schemaMap, ok := jsonObj.(map[string]interface{}); ok {
+			if schemaType, exists := schemaMap["type"]; exists {
+				if typeStr, ok := schemaType.(string); ok {
+					// Common Avro types
+					avroTypes := []string{"record", "enum", "array", "map", "union", "fixed"}
+					for _, avroType := range avroTypes {
+						if typeStr == avroType {
+							return FormatAvro
+						}
+					}
+				}
+			}
+			// Check for JSON Schema indicators
+			if _, exists := schemaMap["$schema"]; exists {
+				return FormatJSONSchema
+			}
+		}
+		// Default JSON-based schema to Avro
+		return FormatAvro
+	}
+
+	// Check for Protobuf (typically not JSON)
+	// Protobuf schemas in Schema Registry are usually stored as descriptors
+	// For now, assume non-JSON schemas are Protobuf
+	return FormatProtobuf
+}
+
+// HealthCheck verifies the registry is accessible
+func (rc *RegistryClient) HealthCheck() error {
+	url := fmt.Sprintf("%s/subjects", rc.baseURL)
+	resp, err := rc.httpClient.Get(url)
+	if err != nil {
+		return fmt.Errorf("schema registry health check failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("schema registry health check failed with status %d", resp.StatusCode)
+	}
+
+	return nil
+}
@@ -0,0 +1,362 @@
+package schema
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func TestNewRegistryClient(t *testing.T) {
+	config := RegistryConfig{
+		URL: "http://localhost:8081",
+	}
+	
+	client := NewRegistryClient(config)
+	
+	if client.baseURL != config.URL {
+		t.Errorf("Expected baseURL %s, got %s", config.URL, client.baseURL)
+	}
+	
+	if client.cacheTTL != 5*time.Minute {
+		t.Errorf("Expected default cacheTTL 5m, got %v", client.cacheTTL)
+	}
+	
+	if client.httpClient.Timeout != 30*time.Second {
+		t.Errorf("Expected default timeout 30s, got %v", client.httpClient.Timeout)
+	}
+}
+
+func TestRegistryClient_GetSchemaByID(t *testing.T) {
+	// Mock server
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/schemas/ids/1" {
+			response := map[string]interface{}{
+				"schema":  `{"type":"record","name":"User","fields":[{"name":"id","type":"int"}]}`,
+				"subject": "user-value",
+				"version": 1,
+			}
+			json.NewEncoder(w).Encode(response)
+		} else if r.URL.Path == "/schemas/ids/999" {
+			w.WriteHeader(http.StatusNotFound)
+			w.Write([]byte(`{"error_code":40403,"message":"Schema not found"}`))
+		} else {
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	config := RegistryConfig{
+		URL:      server.URL,
+		CacheTTL: 1 * time.Minute,
+	}
+	client := NewRegistryClient(config)
+
+	t.Run("successful fetch", func(t *testing.T) {
+		schema, err := client.GetSchemaByID(1)
+		if err != nil {
+			t.Fatalf("Expected no error, got %v", err)
+		}
+		
+		if schema.ID != 1 {
+			t.Errorf("Expected schema ID 1, got %d", schema.ID)
+		}
+		
+		if schema.Subject != "user-value" {
+			t.Errorf("Expected subject 'user-value', got %s", schema.Subject)
+		}
+		
+		if schema.Format != FormatAvro {
+			t.Errorf("Expected Avro format, got %v", schema.Format)
+		}
+	})
+
+	t.Run("schema not found", func(t *testing.T) {
+		_, err := client.GetSchemaByID(999)
+		if err == nil {
+			t.Fatal("Expected error for non-existent schema")
+		}
+	})
+
+	t.Run("cache hit", func(t *testing.T) {
+		// First call should cache the result
+		schema1, err := client.GetSchemaByID(1)
+		if err != nil {
+			t.Fatalf("Expected no error, got %v", err)
+		}
+		
+		// Second call should hit cache (same timestamp)
+		schema2, err := client.GetSchemaByID(1)
+		if err != nil {
+			t.Fatalf("Expected no error, got %v", err)
+		}
+		
+		if schema1.CachedAt != schema2.CachedAt {
+			t.Error("Expected cache hit with same timestamp")
+		}
+	})
+}
+
+func TestRegistryClient_GetLatestSchema(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/subjects/user-value/versions/latest" {
+			response := map[string]interface{}{
+				"id":      uint32(1),
+				"schema":  `{"type":"record","name":"User","fields":[{"name":"id","type":"int"}]}`,
+				"subject": "user-value",
+				"version": 1,
+			}
+			json.NewEncoder(w).Encode(response)
+		} else {
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	config := RegistryConfig{URL: server.URL}
+	client := NewRegistryClient(config)
+
+	schema, err := client.GetLatestSchema("user-value")
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+	
+	if schema.LatestID != 1 {
+		t.Errorf("Expected schema ID 1, got %d", schema.LatestID)
+	}
+	
+	if schema.Subject != "user-value" {
+		t.Errorf("Expected subject 'user-value', got %s", schema.Subject)
+	}
+}
+
+func TestRegistryClient_RegisterSchema(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == "POST" && r.URL.Path == "/subjects/test-value/versions" {
+			response := map[string]interface{}{
+				"id": uint32(123),
+			}
+			json.NewEncoder(w).Encode(response)
+		} else {
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	config := RegistryConfig{URL: server.URL}
+	client := NewRegistryClient(config)
+
+	schemaStr := `{"type":"record","name":"Test","fields":[{"name":"id","type":"int"}]}`
+	id, err := client.RegisterSchema("test-value", schemaStr)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+	
+	if id != 123 {
+		t.Errorf("Expected schema ID 123, got %d", id)
+	}
+}
+
+func TestRegistryClient_CheckCompatibility(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == "POST" && r.URL.Path == "/compatibility/subjects/test-value/versions/latest" {
+			response := map[string]interface{}{
+				"is_compatible": true,
+			}
+			json.NewEncoder(w).Encode(response)
+		} else {
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	config := RegistryConfig{URL: server.URL}
+	client := NewRegistryClient(config)
+
+	schemaStr := `{"type":"record","name":"Test","fields":[{"name":"id","type":"int"}]}`
+	compatible, err := client.CheckCompatibility("test-value", schemaStr)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+	
+	if !compatible {
+		t.Error("Expected schema to be compatible")
+	}
+}
+
+func TestRegistryClient_ListSubjects(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/subjects" {
+			subjects := []string{"user-value", "order-value", "product-key"}
+			json.NewEncoder(w).Encode(subjects)
+		} else {
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	config := RegistryConfig{URL: server.URL}
+	client := NewRegistryClient(config)
+
+	subjects, err := client.ListSubjects()
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+	
+	expectedSubjects := []string{"user-value", "order-value", "product-key"}
+	if len(subjects) != len(expectedSubjects) {
+		t.Errorf("Expected %d subjects, got %d", len(expectedSubjects), len(subjects))
+	}
+	
+	for i, expected := range expectedSubjects {
+		if subjects[i] != expected {
+			t.Errorf("Expected subject %s, got %s", expected, subjects[i])
+		}
+	}
+}
+
+func TestRegistryClient_DetectSchemaFormat(t *testing.T) {
+	config := RegistryConfig{URL: "http://localhost:8081"}
+	client := NewRegistryClient(config)
+
+	tests := []struct {
+		name     string
+		schema   string
+		expected Format
+	}{
+		{
+			name:     "Avro record schema",
+			schema:   `{"type":"record","name":"User","fields":[{"name":"id","type":"int"}]}`,
+			expected: FormatAvro,
+		},
+		{
+			name:     "Avro enum schema",
+			schema:   `{"type":"enum","name":"Color","symbols":["RED","GREEN","BLUE"]}`,
+			expected: FormatAvro,
+		},
+		{
+			name:     "JSON Schema",
+			schema:   `{"$schema":"http://json-schema.org/draft-07/schema#","type":"object"}`,
+			expected: FormatJSONSchema,
+		},
+		{
+			name:     "Protobuf (non-JSON)",
+			schema:   "syntax = \"proto3\"; message User { int32 id = 1; }",
+			expected: FormatProtobuf,
+		},
+		{
+			name:     "Simple Avro primitive",
+			schema:   `{"type":"string"}`,
+			expected: FormatAvro,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			format := client.detectSchemaFormat(tt.schema)
+			if format != tt.expected {
+				t.Errorf("Expected format %v, got %v", tt.expected, format)
+			}
+		})
+	}
+}
+
+func TestRegistryClient_CacheManagement(t *testing.T) {
+	config := RegistryConfig{
+		URL:      "http://localhost:8081",
+		CacheTTL: 100 * time.Millisecond, // Short TTL for testing
+	}
+	client := NewRegistryClient(config)
+
+	// Add some cache entries manually
+	client.schemaCache[1] = &CachedSchema{
+		ID:       1,
+		Schema:   "test",
+		CachedAt: time.Now(),
+	}
+	client.subjectCache["test"] = &CachedSubject{
+		Subject:  "test",
+		CachedAt: time.Now(),
+	}
+
+	// Check cache stats
+	schemaCount, subjectCount := client.GetCacheStats()
+	if schemaCount != 1 || subjectCount != 1 {
+		t.Errorf("Expected 1 schema and 1 subject in cache, got %d and %d", schemaCount, subjectCount)
+	}
+
+	// Clear cache
+	client.ClearCache()
+	schemaCount, subjectCount = client.GetCacheStats()
+	if schemaCount != 0 || subjectCount != 0 {
+		t.Errorf("Expected empty cache after clear, got %d schemas and %d subjects", schemaCount, subjectCount)
+	}
+}
+
+func TestRegistryClient_HealthCheck(t *testing.T) {
+	t.Run("healthy registry", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/subjects" {
+				json.NewEncoder(w).Encode([]string{})
+			}
+		}))
+		defer server.Close()
+
+		config := RegistryConfig{URL: server.URL}
+		client := NewRegistryClient(config)
+
+		err := client.HealthCheck()
+		if err != nil {
+			t.Errorf("Expected healthy registry, got error: %v", err)
+		}
+	})
+
+	t.Run("unhealthy registry", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusInternalServerError)
+		}))
+		defer server.Close()
+
+		config := RegistryConfig{URL: server.URL}
+		client := NewRegistryClient(config)
+
+		err := client.HealthCheck()
+		if err == nil {
+			t.Error("Expected error for unhealthy registry")
+		}
+	})
+}
+
+// Benchmark tests
+func BenchmarkRegistryClient_GetSchemaByID(b *testing.B) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		response := map[string]interface{}{
+			"schema":  `{"type":"record","name":"User","fields":[{"name":"id","type":"int"}]}`,
+			"subject": "user-value",
+			"version": 1,
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	config := RegistryConfig{URL: server.URL}
+	client := NewRegistryClient(config)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = client.GetSchemaByID(1)
+	}
+}
+
+func BenchmarkRegistryClient_DetectSchemaFormat(b *testing.B) {
+	config := RegistryConfig{URL: "http://localhost:8081"}
+	client := NewRegistryClient(config)
+	
+	avroSchema := `{"type":"record","name":"User","fields":[{"name":"id","type":"int"}]}`
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = client.detectSchemaFormat(avroSchema)
+	}
+}