go-duck-cli 1.3.371 → 1.4.5

package/README.md

@@ -77,7 +77,7 @@ GO-DUCK has officially reached the **410% Achievement Status**, evolving from a
 *   **Zero-Trust Identity Registry**: Decoupled mapping layer ensuring physical database names and internal IDs never leak to the client.
 *   **Universal Storage Mesh**: Dynamic Multi-Provider Registry allowing hot-swapping at runtime via `?provider=` queries, alongside Distributed Cross-Scan endpoints to auto-locate files across AWS, GCS, SFTP, and GitHub lakes.
 *   **Enterprise API Gateway Compatibility**: Natively exposes the Swagger/OpenAPI JSON specification at `/v3/api-docs` to ensure drop-in compatibility with **JHipster**, **WSO2 API Manager**, and Spring Boot ecosystems.
-*   **Next-Gen Swagger UI**: A fully glassmorphism-styled Swagger UI with seamless Keycloak SSO integration. Features automatic JWT token refresh, dynamic `X-Tenant-ID` header injection, and CLI metadata branding.
+*   **Next-Gen Swagger UI**: A fully glassmorphism-styled Swagger UI with seamless Keycloak SSO integration. Features automatic JWT token refresh, dynamic `X-Tenant-ID` header injection, and CLI metadata branding. Now features a **Live Interactive MQTT Dictionary**, allowing users to instantly subscribe or publish payloads directly from the docs via WebSockets!
 *   **Spring-style Elasticsearch Search**: Real-time sync for entities marked with `@Searchable`, supporting native `query_string` syntax (wildcards like `*`, booleans, ranges, and fuzzy matching).
 *   **SaaS Quota Engine**: Redis-backed API bandwidth tracking with dynamic, hierarchical limits (User vs. Role mapping).
 *   **Resilience Layer**: Sony/Gobreaker Integration + Zero-Trust Distributed Redis Rate Limiter.
@@ -238,6 +238,15 @@ GO-DUCK automatically exposes your microservice across three distinct ports to s
    ```
    *Frontend Tip: Use the `grpc-web` npm package to generate a frontend client that communicates with this port!*
 
+## 📊 Telemetry & Observability
+GO-DUCK automatically integrates industrial observability stack:
+1. **OpenTelemetry Distributed Tracing**: Native `otelgin` and `gorm.io/plugin/opentelemetry/tracing` integrations.
+2. **Triple-Metrics Endpoints**: 
+   - `GET /metrics`: Standard Prometheus scraping endpoint for Kubernetes Horizontal Pod Autoscaling (HPA).
+   - `GET /api/system/stream`: A Server-Sent Events (SSE) endpoint streaming live JSON payloads of CPU, Memory, and Load Percentages directly to your browser for real-time dashboards.
+   - `GET /api/system/metrics`: A massive JSON endpoint returning JHipster-style metrics (Go GC pauses, Uptime, Goroutines, exact endpoint hits, latencies, and failed calls).
+3. **Datadog Logging**: Environment-driven log streaming and monitoring natively via `logger` package.
+
 ## Usage
 
 The `go-duck-cli` has two main commands: `create` and `import-gdl`.
@@ -390,6 +399,16 @@ go-duck:
       rps: 100
       burst: 200
 
+  # --- Telemetry & Metrics ---
+  telemetry:
+    otel:
+      enabled: true
+      endpoint: "localhost:4317"
+    metrics:
+      prometheus-enabled: true
+      stream-enabled: true
+      stream-interval: "1s"
+
   # --- Federated Multi-Tenancy ---
   multitenancy:
     enabled: true

package/generators/config.js

@@ -106,6 +106,11 @@ type Config struct {
 				Endpoint     string  \`mapstructure:"endpoint"\`
 				SamplerRatio float64 \`mapstructure:"sampler-ratio"\`
 			} \`mapstructure:"otel"\`
+			Metrics struct {
+				PrometheusEnabled bool          \`mapstructure:"prometheus-enabled"\`
+				StreamEnabled     bool          \`mapstructure:"stream-enabled"\`
+				StreamInterval    time.Duration \`mapstructure:"stream-interval"\`
+			} \`mapstructure:"metrics"\`
 		} \`mapstructure:"telemetry"\`
 
 		Resilience struct {
@@ -262,6 +267,9 @@ func LoadConfig() (*Config, error) {
 	v.SetDefault("go-duck.telemetry.otel.enabled", false)
 	v.SetDefault("go-duck.telemetry.otel.endpoint", "localhost:4317")
 	v.SetDefault("go-duck.telemetry.otel.sampler-ratio", 1.0)
+	v.SetDefault("go-duck.telemetry.metrics.prometheus-enabled", true)
+	v.SetDefault("go-duck.telemetry.metrics.stream-enabled", true)
+	v.SetDefault("go-duck.telemetry.metrics.stream-interval", "1s")
 	v.SetDefault("go-duck.server.grpc.addr", ":9000")
 	v.SetDefault("go-duck.server.grpc.network", "tcp")
 	v.SetDefault("go-duck.server.grpc.timeout", "1s")

package/generators/devops.js

@@ -13,7 +13,12 @@ export const generateDeploymentArtifacts = async (config, projectRootDir) => {
     await fs.ensureDir(keycloakDir);
     await fs.ensureDir(githubDir);
 
+    const toKebabCase = (str) => {
+        if (!str) return '';
+        return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+    };
     const appName = config.name || 'go-duck';
+    const k8sAppName = toKebabCase(appName);
     const parts = appName.split(/[-_]/);
     const shortName = (parts.length > 1 ? parts.map(w => w[0]).join('') : appName).substring(0, 10).toLowerCase() || 'goduck';
     const appPort = config.server?.rest?.port || 8080;
@@ -75,9 +80,11 @@ FROM gcr.io/distroless/static-debian12
 WORKDIR /app
 
 COPY --from=builder /app/server .
+
 COPY --from=builder /app/application.yml .
 COPY --from=builder /app/application-dev.yml .
 COPY --from=builder /app/application-prod.yml .
+COPY --from=builder /app/docs/ /app/docs/
 
 EXPOSE ${appPort}
 ENV GO_PROFILE=prod
@@ -468,21 +475,21 @@ echo "========================================="
     const k8sAppYaml = `apiVersion: apps/v1
 kind: Deployment
 metadata:
-  name: ${appName}
+  name: ${k8sAppName}
   labels:
-    app: ${appName}
+    app: ${k8sAppName}
 spec:
   replicas: 1
   selector:
     matchLabels:
-      app: ${appName}
+      app: ${k8sAppName}
   template:
     metadata:
       labels:
-        app: ${appName}
+        app: ${k8sAppName}
     spec:
       containers:
-        - name: ${appName}
+        - name: ${k8sAppName}
           image: ${appName}:latest
           env:
             - name: GO_PROFILE
@@ -490,7 +497,7 @@ spec:
             - name: GO_DUCK_SERVER_REST_PORT
               value: "${appPort}"
             - name: GO_DUCK_DATASOURCE_HOST
-              value: postgres.${shortName}-postgres-k8s.svc.cluster.local
+              value: postgres.${k8sAppName}-postgres-k8s.svc.cluster.local
             - name: GO_DUCK_DATASOURCE_USERNAME
               value: "${config.datasource?.username || 'postgres'}"
             - name: GO_DUCK_DATASOURCE_PASSWORD
@@ -502,31 +509,31 @@ spec:
             - name: GO_DUCK_DATASOURCE_MONGODB_ENABLED
               value: "${config.datasource?.mongodb?.enabled ? 'true' : 'false'}"
             - name: GO_DUCK_DATASOURCE_MONGODB_URI
-              value: mongodb://mongodb.${shortName}-mongodb-k8s.svc.cluster.local:27017
+              value: mongodb://mongodb.${k8sAppName}-mongodb-k8s.svc.cluster.local:27017
             - name: GO_DUCK_DATASOURCE_MONGODB_DATABASE
               value: "${config.datasource?.mongodb?.database || 'goduck_document_store'}"
             - name: GO_DUCK_CACHE_REDIS_HOST
-              value: redis.${shortName}-redis-k8s.svc.cluster.local:6379
+              value: redis.${k8sAppName}-redis-k8s.svc.cluster.local:6379
             - name: GO_DUCK_CACHE_REDIS_PASSWORD
               value: "${config.cache?.redis?.password || ''}"
             - name: GO_DUCK_MESSAGING_MQTT_BROKER
-              value: tcp://mosquitto.${shortName}-mosquitto-k8s.svc.cluster.local:1883
+              value: tcp://mosquitto.${k8sAppName}-mosquitto-k8s.svc.cluster.local:1883
             - name: GO_DUCK_MESSAGING_MQTT_USERNAME
               value: "${config.messaging?.mqtt?.username || 'dev_user'}"
             - name: GO_DUCK_MESSAGING_MQTT_PASSWORD
               value: "${config.messaging?.mqtt?.password || 'dev_password'}"
             - name: GO_DUCK_MESSAGING_NATS_URL
-              value: nats://nats.${shortName}-nats-k8s.svc.cluster.local:4222
+              value: nats://nats.${k8sAppName}-nats-k8s.svc.cluster.local:4222
             - name: GO_DUCK_TELEMETRY_OTEL_ENDPOINT
-              value: otel-collector.${shortName}-otel-collector-k8s.svc.cluster.local:4317
+              value: otel-collector.${k8sAppName}-otel-collector-k8s.svc.cluster.local:4317
             - name: GO_DUCK_ELASTICSEARCH_ADDRESSES
-              value: http://elasticsearch.${shortName}-elasticsearch-k8s.svc.cluster.local:9200
+              value: http://elasticsearch.${k8sAppName}-elasticsearch-k8s.svc.cluster.local:9200
             - name: GO_DUCK_ELASTICSEARCH_USERNAME
               value: "${config.elasticsearch?.username || 'elastic'}"
             - name: GO_DUCK_ELASTICSEARCH_PASSWORD
               value: "${config.elasticsearch?.password || 'changeme'}"
             - name: GO_DUCK_SECURITY_KEYCLOAK_HOST
-              value: http://keycloak.${shortName}-keycloak-k8s.svc.cluster.local:8080
+              value: http://keycloak.${k8sAppName}-keycloak-k8s.svc.cluster.local:8080
             - name: GO_DUCK_SECURITY_KEYCLOAK_REALM
               value: "${config.security?.['keycloak-realm'] || 'go-duck-realm'}"
             - name: GO_DUCK_SECURITY_KEYCLOAK_APP_CLIENT_ID
@@ -536,7 +543,7 @@ spec:
             - name: GO_DUCK_SECURITY_KEYCLOAK_SERVICE_SECRET
               value: "${config.security?.['keycloak-service-secret'] || 'service-secret-123'}"
             - name: GO_DUCK_STORAGE_MINIO_ENDPOINT
-              value: "http://minio.${shortName}-minio-k8s.svc.cluster.local:9000"
+              value: "http://minio.${k8sAppName}-minio-k8s.svc.cluster.local:9000"
             - name: GO_DUCK_STORAGE_MINIO_ACCESS_KEY
               value: "${config.storage?.minio?.['access-key'] || 'minioadmin'}"
             - name: GO_DUCK_STORAGE_MINIO_SECRET_KEY
@@ -550,7 +557,7 @@ spec:
 apiVersion: v1
 kind: Service
 metadata:
-  name: ${appName}
+  name: ${k8sAppName}
 spec:
   type: NodePort
   ports:
@@ -563,7 +570,7 @@ spec:
       targetPort: grpc
       nodePort: 30090
   selector:
-    app: ${appName}
+    app: ${k8sAppName}
 `;
 
     const k8sPostgresYaml = `apiVersion: v1
@@ -1001,7 +1008,7 @@ spec:
     await fs.writeFile(path.join(k8sDir, 'mosquitto.conf'), mosquittoConf);
     // Namespace calculation: unique namespace per service
     const applyNs = (yamlString, serviceName) => {
-        const nsName = `${shortName}-${serviceName}-k8s`;
+        const nsName = `${k8sAppName}-${serviceName}-k8s`;
         const nsBlock = `apiVersion: v1\nkind: Namespace\nmetadata:\n  name: ${nsName}\n---\n`;
         return nsBlock + yamlString.replace(/^metadata:$/gm, `metadata:\n  namespace: ${nsName}`);
     };
@@ -1012,7 +1019,7 @@ spec:
     // We conditionally add minio if storage is enabled (or any blob provider), but for safety we'll just generate its namespace always.
     servicesList.push('minio');
 
-    const k8sNamespaceYaml = servicesList.map(svc => `apiVersion: v1\nkind: Namespace\nmetadata:\n  name: ${shortName}-${svc}-k8s`).join('\n---\n');
+    const k8sNamespaceYaml = servicesList.map(svc => `apiVersion: v1\nkind: Namespace\nmetadata:\n  name: ${k8sAppName}-${svc}-k8s`).join('\n---\n');
 
     await fs.writeFile(path.join(k8sDir, 'namespace.yaml'), k8sNamespaceYaml);
 

package/generators/logger.js

@@ -10,8 +10,10 @@ export const generateLoggerCode = async (config, outputDir) => {
 package logger
 
 import (
+	"io"
 	"log"
 	"os"
+	"sync"
 	"{{app_name}}/config"
 
 	"github.com/DataDog/datadog-go/statsd"
@@ -19,8 +21,52 @@ import (
 
 var (
 	Statsd *statsd.Client
+	GlobalLogBroker = NewLogBroker()
 )
 
+// LogBroker broadcasts log messages to SSE clients
+type LogBroker struct {
+	clients map[chan []byte]bool
+	mu      sync.RWMutex
+}
+
+func NewLogBroker() *LogBroker {
+	return &LogBroker{
+		clients: make(map[chan []byte]bool),
+	}
+}
+
+func (b *LogBroker) AddClient(client chan []byte) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.clients[client] = true
+}
+
+func (b *LogBroker) RemoveClient(client chan []byte) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	delete(b.clients, client)
+	close(client)
+}
+
+// Write implements io.Writer
+func (b *LogBroker) Write(p []byte) (n int, err error) {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	
+	msg := make([]byte, len(p))
+	copy(msg, p)
+
+	for client := range b.clients {
+		select {
+		case client <- msg:
+		default:
+			// Client channel full, drop to avoid blocking
+		}
+	}
+	return len(p), nil
+}
+
 // InitLogger initializes the application logging and monitoring
 func InitLogger(cfg *config.Config) {
 	if cfg.GoDuck.Logging.Datadog.Enabled {
@@ -42,7 +88,10 @@ func InitLogger(cfg *config.Config) {
 
 	// Set standard logger output
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
-	log.SetOutput(os.Stdout)
+	
+	// Create a MultiWriter to duplicate logs to both os.Stdout and the GlobalLogBroker
+	mw := io.MultiWriter(os.Stdout, GlobalLogBroker)
+	log.SetOutput(mw)
 }
 
 // Info logs information messages

package/generators/mqtt-topics.js

@@ -0,0 +1,54 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateMQTTTopicsJSON = async (config, entities, outputDir) => {
+    const docsDir = path.join(outputDir, 'docs');
+    await fs.ensureDir(docsDir);
+
+    const jsonFilePath = path.join(docsDir, 'mqtt_topics.json5');
+    const needle = '// needle-mqtt-topics-add-below';
+
+    let content = '';
+    if (await fs.pathExists(jsonFilePath)) {
+        content = await fs.readFile(jsonFilePath, 'utf8');
+    } else {
+        content = `{
+  "topics": {
+    // Custom topics can be added here manually.
+    
+    ${needle}
+  }
+}`;
+    }
+
+    const topicPrefix = config.messaging?.mqtt?.['topic-prefix'] || 'go-duck/events';
+    let newEntries = '';
+
+    for (const entity of entities) {
+        const entityName = entity.name.toLowerCase();
+        const baseTopic = `${topicPrefix}/${entityName}`;
+
+        const createdTopic = `"${baseTopic}/created"`;
+        if (!content.includes(createdTopic)) {
+            newEntries += `    // Auto-generated topics for ${entity.name}\n`;
+            newEntries += `    ${createdTopic}: "Triggered when a new ${entity.name} is created.",\n`;
+            newEntries += `    "${baseTopic}/updated": "Triggered when an existing ${entity.name} is updated.",\n`;
+            newEntries += `    "${baseTopic}/deleted": "Triggered when a ${entity.name} is deleted.",\n\n`;
+        }
+    }
+
+    if (newEntries.length > 0) {
+        if (content.includes(needle)) {
+            content = content.replace(needle, newEntries + `    ${needle}`);
+        } else {
+            // Fallback if needle is missing somehow
+            content = content.replace(/}\s*}$/, `,\n${newEntries}\n  }\n}`);
+        }
+        
+        await fs.writeFile(jsonFilePath, content);
+        console.log(chalk.gray('  Updated MQTT Topics Dictionary: mqtt_topics.json5'));
+    } else {
+        console.log(chalk.gray('  MQTT Topics Dictionary up to date.'));
+    }
+};

package/generators/postman.js

@@ -364,8 +364,9 @@ export const generatePostmanCollection = async (config, entities, outputDir, ope
             else if (f.type === 'Float' || f.type === 'BigDecimal') obj[f.name] = 99.99;
             else if (f.type === 'Boolean') obj[f.name] = true;
             else if (f.type === 'LocalDate') obj[f.name] = "2024-01-01";
-            else if (f.type === 'Instant') obj[f.name] = "2024-01-01T12:00:00Z";
+            else if (f.type === 'Instant' || f.type === 'DateTime' || f.type === 'Datetime') obj[f.name] = "2024-01-01T12:00:00Z";
             else if (f.type === 'JSON' || f.type === 'JSONB') obj[f.name] = {"attribute": "example_value"};
+            else if (f.isEnum) obj[f.name] = "ACTIVE"; // Safe fallback for enums
             else obj[f.name] = "test";
         }
         return JSON.stringify(obj, null, 2);

package/generators/swagger.js

@@ -17,7 +17,7 @@ export const generateSwaggerDocs = async (config, entities, outputDir, openEntit
             description: `Generated documentation for ${config.name} microservice`
         },
         servers: [
-            { url: `http://localhost:${config.server?.rest?.port || 8080}`, description: 'Local Development Server' }
+            { url: "/", description: "Current Host" }
         ],
         paths: {},
         components: {
@@ -51,7 +51,7 @@ export const generateSwaggerDocs = async (config, entities, outputDir, openEntit
     };
 
     const commonHeaders = [
-        { name: 'X-Tenant-ID', in: 'header', required: true, schema: { type: 'string', default: 'default' }, description: 'Multi-tenancy context identifier' }
+        { name: 'X-Tenant-ID', in: 'header', required: false, schema: { type: 'string', default: 'default' }, description: 'Multi-tenancy context identifier' }
     ];
 
     const isOpen = (entityName, action) => {
@@ -84,7 +84,7 @@ export const generateSwaggerDocs = async (config, entities, outputDir, openEntit
             properties: {
                 id: { type: 'integer' },
                 ...entity.fields.reduce((acc, field) => {
-                    acc[field.name] = { type: mapToSwaggerType(field.type) };
+                    acc[field.name] = getSwaggerFieldSchema(field.type);
                     return acc;
                 }, {}),
                 createdAt: { type: 'string', format: 'date-time' },
@@ -273,7 +273,7 @@ export const generateSwaggerDocs = async (config, entities, outputDir, openEntit
                 }
             },
             parameters: [
-                { name: 'X-Tenant-ID', in: 'header', required: true, schema: { type: 'string', default: 'master_internal' }, description: 'SuperAdmin internal master bypass token' }
+                { name: 'X-Tenant-ID', in: 'header', required: false, schema: { type: 'string', default: 'master_internal' }, description: 'SuperAdmin internal master bypass token' }
             ],
             responses: {
                 200: { description: 'Success' },
@@ -318,19 +318,19 @@ export const generateSwaggerDocs = async (config, entities, outputDir, openEntit
     console.log(chalk.gray('  Generated Swagger Documentation: swagger.json'));
 };
 
-const mapToSwaggerType = (type) => {
-    const types = {
-        'String': 'string',
-        'Integer': 'integer',
-        'Float': 'number',
-        'Boolean': 'boolean',
-        'Long': 'integer',
-        'BigDecimal': 'number',
-        'LocalDate': 'string',
-        'Instant': 'string',
-        'JSON': 'object',
-        'JSONB': 'object',
-        'Text': 'string'
+const getSwaggerFieldSchema = (type) => {
+    const schemas = {
+        'String': { type: 'string' },
+        'Integer': { type: 'integer', format: 'int32' },
+        'Float': { type: 'number', format: 'double' },
+        'Boolean': { type: 'boolean' },
+        'Long': { type: 'integer', format: 'int64' },
+        'BigDecimal': { type: 'number', format: 'double' },
+        'LocalDate': { type: 'string', format: 'date' },
+        'Instant': { type: 'string', format: 'date-time' },
+        'JSON': { type: 'object' },
+        'JSONB': { type: 'object' },
+        'Text': { type: 'string' }
     };
-    return types[type] || 'string';
+    return schemas[type] || { type: 'string' };
 };

package/generators/telemetry.js

@@ -105,7 +105,174 @@ service:
       exporters: [logging, otlp]
 `;
 
+	const metricsCollectorGo = `
+package telemetry
+
+import (
+	"runtime"
+	"sync"
+	"time"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"{{app_name}}/config"
+)
+
+type EndpointStats struct {
+	Count       int64   \`json:"count"\`
+	MeanTime    float64 \`json:"mean_time_ms"\`
+	MaxTime     float64 \`json:"max_time_ms"\`
+	TotalTime   float64 \`json:"-"\`
+}
+
+type StatusStats struct {
+	Count    int64   \`json:"count"\`
+	MeanTime float64 \`json:"mean_time_ms"\`
+	MaxTime  float64 \`json:"max_time_ms"\`
+	TotalTime float64 \`json:"-"\`
+}
+
+type AppMetrics struct {
+	mu           sync.RWMutex
+	StartTime    time.Time
+	Endpoints    map[string]*EndpointStats
+	StatusCodes  map[int]*StatusStats
+	FailedCalls  int64
+}
+
+var globalMetrics = &AppMetrics{
+	StartTime:   time.Now(),
+	Endpoints:   make(map[string]*EndpointStats),
+	StatusCodes: make(map[int]*StatusStats),
+}
+
+func MetricsTrackingMiddleware(cfg *config.Config) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+		c.Next()
+		duration := float64(time.Since(start).Milliseconds())
+		
+		status := c.Writer.Status()
+		method := c.Request.Method
+		path := c.FullPath()
+		if path == "" {
+			path = "unknown"
+		}
+		endpointKey := method + " " + path
+
+		globalMetrics.mu.Lock()
+		defer globalMetrics.mu.Unlock()
+
+		// Status Code tracking
+		if _, exists := globalMetrics.StatusCodes[status]; !exists {
+			globalMetrics.StatusCodes[status] = &StatusStats{}
+		}
+		sStat := globalMetrics.StatusCodes[status]
+		sStat.Count++
+		sStat.TotalTime += duration
+		sStat.MeanTime = sStat.TotalTime / float64(sStat.Count)
+		if duration > sStat.MaxTime {
+			sStat.MaxTime = duration
+		}
+
+		if status >= 400 {
+			globalMetrics.FailedCalls++
+		}
+
+		// Endpoint tracking
+		if _, exists := globalMetrics.Endpoints[endpointKey]; !exists {
+			globalMetrics.Endpoints[endpointKey] = &EndpointStats{}
+		}
+		eStat := globalMetrics.Endpoints[endpointKey]
+		eStat.Count++
+		eStat.TotalTime += duration
+		eStat.MeanTime = eStat.TotalTime / float64(eStat.Count)
+		if duration > eStat.MaxTime {
+			eStat.MaxTime = duration
+		}
+	}
+}
+
+func GetGlobalMetrics() *AppMetrics {
+	return globalMetrics
+}
+`;
+
+	const systemMetricsGo = `
+package telemetry
+
+import (
+	"runtime"
+	"time"
+	"github.com/shirou/gopsutil/v3/cpu"
+	"github.com/shirou/gopsutil/v3/mem"
+	"github.com/shirou/gopsutil/v3/process"
+	"os"
+	"fmt"
+)
+
+type SystemMetrics struct {
+	Uptime           string  \`json:"uptime"\`
+	StartTime        string  \`json:"start_time"\`
+	ProcessCPUUsage  float64 \`json:"process_cpu_usage"\`
+	SystemCPUUsage   float64 \`json:"system_cpu_usage"\`
+	SystemCPUCount   int     \`json:"system_cpu_count"\`
+	ProcessFilesOpen int32   \`json:"process_files_open"\`
+	
+	HeapAllocMB      uint64  \`json:"heap_alloc_mb"\`
+	HeapSysMB        uint64  \`json:"heap_sys_mb"\`
+	NumGC            uint32  \`json:"num_gc"\`
+	PauseTotalMs     uint64  \`json:"gc_pause_total_ms"\`
+	Goroutines       int     \`json:"goroutines"\`
+}
+
+func CollectSystemMetrics() SystemMetrics {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+
+	cpuPercent, _ := cpu.Percent(0, false)
+	sysCPU := 0.0
+	if len(cpuPercent) > 0 {
+		sysCPU = cpuPercent[0]
+	}
+	
+	p, err := process.NewProcess(int32(os.Getpid()))
+	procCPU := 0.0
+	var openFiles int32 = 0
+	if err == nil {
+		procCPU, _ = p.CPUPercent()
+		files, _ := p.OpenFiles()
+		openFiles = int32(len(files))
+	}
+
+	appMetrics := GetGlobalMetrics()
+	uptime := time.Since(appMetrics.StartTime)
+	
+	// Convert uptime duration to readable string like "10 days 4 hours..."
+	days := int(uptime.Hours()) / 24
+	hours := int(uptime.Hours()) % 24
+	mins := int(uptime.Minutes()) % 60
+	secs := int(uptime.Seconds()) % 60
+	uptimeStr := fmt.Sprintf("%d days %d hours %d minutes %d seconds", days, hours, mins, secs)
+
+	return SystemMetrics{
+		Uptime:           uptimeStr,
+		StartTime:        appMetrics.StartTime.Format(time.RFC1123),
+		ProcessCPUUsage:  procCPU,
+		SystemCPUUsage:   sysCPU,
+		SystemCPUCount:   runtime.NumCPU(),
+		ProcessFilesOpen: openFiles,
+		HeapAllocMB:      m.HeapAlloc / 1024 / 1024,
+		HeapSysMB:        m.HeapSys / 1024 / 1024,
+		NumGC:            m.NumGC,
+		PauseTotalMs:     m.PauseTotalNs / 1000000,
+		Goroutines:       runtime.NumGoroutine(),
+	}
+}
+`;
+
     await fs.writeFile(path.join(telemetryDir, 'otel.go'), otelGo.replace(/{{app_name}}/g, config.name));
+    await fs.writeFile(path.join(telemetryDir, 'metrics_collector.go'), metricsCollectorGo.replace(/{{app_name}}/g, config.name));
+    await fs.writeFile(path.join(telemetryDir, 'system_metrics.go'), systemMetricsGo.replace(/{{app_name}}/g, config.name));
     await fs.writeFile(path.join(k8sDir, 'otel-collector.yml'), otelCollectorK8s.replace(/{{app_name}}/g, config.name));
 
     console.log(chalk.gray('  Generated OpenTelemetry Telemetry Package & K8s Config'));

package/index.js

@@ -31,6 +31,7 @@ import { generateWebSocketCode } from './generators/websocket.js';
 import { generateConfigLoader } from './generators/config.js';
 import { generateLoggerCode } from './generators/logger.js';
 import { generateMQTTCode } from './generators/mqtt.js';
+import { generateMQTTTopicsJSON } from './generators/mqtt-topics.js';
 import { generateCacheCode } from './generators/cache.js';
 import { generateResilienceCode } from './generators/resilience.js';
 import { generateTelemetryCode } from './generators/telemetry.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "go-duck-cli",
-  "version": "1.3.371",
+  "version": "1.4.5",
   "description": "The Ultimate Evolutionary Go Microservice Scaffolder.",
   "main": "index.js",
   "type": "module",