go-duck-cli 1.4.6 → 1.4.10

package/test-go/internal/telemetry/otel.go

@@ -0,0 +1,69 @@
+
+package telemetry
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"undefined/config"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/sdk/resource"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+// InitTelemetry initializes OpenTelemetry SDK
+func InitTelemetry(cfg *config.Config) (func(context.Context) error, error) {
+	if !cfg.GoDuck.Telemetry.OTel.Enabled {
+		log.Println("OpenTelemetry is disabled.")
+		return func(context.Context) error { return nil }, nil
+	}
+
+	ctx := context.Background()
+
+	// 1. Setup Resource
+	res, err := resource.New(ctx,
+		resource.WithAttributes(
+			semconv.ServiceNameKey.String(cfg.GoDuck.Name),
+			semconv.ServiceVersionKey.String(cfg.GoDuck.Version),
+		),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create resource: %w", err)
+	}
+
+	// 2. Setup OTLP Exporter (gRPC)
+	conn, err := grpc.DialContext(ctx, cfg.GoDuck.Telemetry.OTel.Endpoint,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithBlock(),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create gRPC connection to OTel collector: %w", err)
+	}
+
+	traceExporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithGRPCConn(conn))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create trace exporter: %w", err)
+	}
+
+	// 3. Setup Tracer Provider
+	bsp := sdktrace.NewBatchSpanProcessor(traceExporter)
+	tp := sdktrace.NewTracerProvider(
+		sdktrace.WithSampler(sdktrace.TraceIDRatioBased(cfg.GoDuck.Telemetry.OTel.SamplerRatio)),
+		sdktrace.WithResource(res),
+		sdktrace.WithSpanProcessor(bsp),
+	)
+	otel.SetTracerProvider(tp)
+
+	// 4. Setup Text Map Propagator
+	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
+
+	log.Printf("OpenTelemetry initialized with endpoint: %s", cfg.GoDuck.Telemetry.OTel.Endpoint)
+
+	return tp.Shutdown, nil
+}

package/test-go/internal/telemetry/system_metrics.go

@@ -0,0 +1,198 @@
+
+package telemetry
+
+import (
+	"runtime"
+	"time"
+	"github.com/shirou/gopsutil/v3/cpu"
+	"github.com/shirou/gopsutil/v3/process"
+	"github.com/shirou/gopsutil/v3/mem"
+	"os"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+var (
+	cgroupCPULock     sync.Mutex
+	lastCgroupTime    time.Time
+	lastCgroupUsageNs uint64
+)
+
+type SystemMetrics struct {
+	Uptime           string  `json:"uptime"`
+	StartTime        string  `json:"start_time"`
+	ProcessCPUUsage  float64 `json:"process_cpu_usage"`
+	SystemCPUUsage   float64 `json:"system_cpu_usage"`
+	PodCPULimitPct   float64 `json:"pod_cpu_limit_pct"`
+	IsPodCPULimited  bool    `json:"is_pod_cpu_limited"`
+	CPUThreadsUsage  []float64 `json:"cpu_threads_usage"`
+	SystemCPUCount   int     `json:"system_cpu_count"`
+	ProcessFilesOpen int32   `json:"process_files_open"`
+	
+	TotalMemMB       uint64  `json:"total_mem_mb"`
+	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 getContainerMemoryLimit() uint64 {
+	// Check cgroup v2
+	if data, err := os.ReadFile("/sys/fs/cgroup/memory.max"); err == nil {
+		val := strings.TrimSpace(string(data))
+		if val != "max" && val != "" {
+			if limit, err := strconv.ParseUint(val, 10, 64); err == nil {
+				return limit
+			}
+		}
+	}
+	// Check cgroup v1
+	if data, err := os.ReadFile("/sys/fs/cgroup/memory/memory.limit_in_bytes"); err == nil {
+		val := strings.TrimSpace(string(data))
+		if limit, err := strconv.ParseUint(val, 10, 64); err == nil {
+			// Some systems report an absurdly high number (e.g. 9223372036854771712) for "no limit"
+			if limit < 9000000000000000000 {
+				return limit
+			}
+		}
+	}
+	return 0
+}
+
+func getCgroupCPUUsageNs() (uint64, error) {
+	// try v2
+	if data, err := os.ReadFile("/sys/fs/cgroup/cpu.stat"); err == nil {
+		lines := strings.Split(string(data), "
+")
+		for _, line := range lines {
+			if strings.HasPrefix(line, "usage_usec") {
+				parts := strings.Fields(line)
+				if len(parts) == 2 {
+					if usec, err := strconv.ParseUint(parts[1], 10, 64); err == nil {
+						return usec * 1000, nil // to nanoseconds
+					}
+				}
+			}
+		}
+	}
+	// try v1
+	if data, err := os.ReadFile("/sys/fs/cgroup/cpuacct/cpuacct.usage"); err == nil {
+		val := strings.TrimSpace(string(data))
+		if ns, err := strconv.ParseUint(val, 10, 64); err == nil {
+			return ns, nil
+		}
+	}
+	return 0, fmt.Errorf("not found")
+}
+
+func getCgroupCPULimitCores() float64 {
+	// check v2
+	if data, err := os.ReadFile("/sys/fs/cgroup/cpu.max"); err == nil {
+		parts := strings.Fields(strings.TrimSpace(string(data)))
+		if len(parts) == 2 && parts[0] != "max" {
+			max, err1 := strconv.ParseFloat(parts[0], 64)
+			period, err2 := strconv.ParseFloat(parts[1], 64)
+			if err1 == nil && err2 == nil && period > 0 {
+				return max / period
+			}
+		}
+	}
+	// check v1
+	if quotaData, err := os.ReadFile("/sys/fs/cgroup/cpu/cpu.cfs_quota_us"); err == nil {
+		quotaStr := strings.TrimSpace(string(quotaData))
+		if quotaStr != "-1" {
+			if quota, err := strconv.ParseFloat(quotaStr, 64); err == nil {
+				if periodData, err := os.ReadFile("/sys/fs/cgroup/cpu/cpu.cfs_period_us"); err == nil {
+					if period, err := strconv.ParseFloat(strings.TrimSpace(string(periodData)), 64); err == nil && period > 0 {
+						return quota / period
+					}
+				}
+			}
+		}
+	}
+	return 0
+}
+
+func CollectSystemMetrics() SystemMetrics {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+
+	cpuPercent, _ := cpu.Percent(0, false)
+	threadsPercent, _ := cpu.Percent(0, true)
+	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))
+	}
+
+	vMem, _ := mem.VirtualMemory()
+	totalMemMB := uint64(0)
+	
+	// 1. Try Kubernetes / Docker Cgroup Limits first
+	cgroupLimitBytes := getContainerMemoryLimit()
+	if cgroupLimitBytes > 0 {
+		totalMemMB = cgroupLimitBytes / 1024 / 1024
+	} else if vMem != nil {
+		// 2. Fallback to underlying physical host memory
+		totalMemMB = vMem.Total / 1024 / 1024
+	}
+
+	appMetrics := GetGlobalMetrics()
+	uptime := time.Since(appMetrics.StartTime)
+	
+	uptimeStr := fmt.Sprintf("%d days, %d hours, %d minutes", 
+		int(uptime.Hours())/24, int(uptime.Hours())%24, int(uptime.Minutes())%60)
+
+	podCPULimitPct := 0.0
+	isPodCPULimited := false
+	
+	limitCores := getCgroupCPULimitCores()
+	if limitCores > 0 {
+		isPodCPULimited = true
+		cgroupCPULock.Lock()
+		usageNs, err := getCgroupCPUUsageNs()
+		now := time.Now()
+		if err == nil {
+			if !lastCgroupTime.IsZero() && usageNs > lastCgroupUsageNs {
+				timeDelta := float64(now.Sub(lastCgroupTime).Nanoseconds())
+				usageDelta := float64(usageNs - lastCgroupUsageNs)
+				if timeDelta > 0 {
+					coresUsed := usageDelta / timeDelta
+					podCPULimitPct = (coresUsed / limitCores) * 100.0
+				}
+			}
+			lastCgroupUsageNs = usageNs
+			lastCgroupTime = now
+		}
+		cgroupCPULock.Unlock()
+	}
+
+	return SystemMetrics{
+		Uptime:           uptimeStr,
+		StartTime:        appMetrics.StartTime.Format(time.RFC1123),
+		ProcessCPUUsage:  procCPU,
+		SystemCPUUsage:   sysCPU,
+		PodCPULimitPct:   podCPULimitPct,
+		IsPodCPULimited:  isPodCPULimited,
+		CPUThreadsUsage:  threadsPercent,
+		SystemCPUCount:   runtime.NumCPU(),
+		ProcessFilesOpen: openFiles,
+		TotalMemMB:       totalMemMB,
+		HeapAllocMB:      m.HeapAlloc / 1024 / 1024,
+		HeapSysMB:        m.HeapSys / 1024 / 1024,
+		NumGC:            m.NumGC,
+		PauseTotalMs:     m.PauseTotalNs / 1000000,
+		Goroutines:       runtime.NumGoroutine(),
+	}
+}

package/test_datatypes.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"gorm.io/datatypes"
+)
+
+type TestStruct struct {
+	D datatypes.Date `json:"d"`
+	T datatypes.Time `json:"t"`
+}
+
+func main() {
+	j := `{"d": "2024-01-01", "t": "12:00:00"}`
+	var ts TestStruct
+	fmt.Println("Err:", json.Unmarshal([]byte(j), &ts))
+	fmt.Println("Result:", ts)
+}

package/test_time.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+type TestStruct struct {
+	T time.Time `json:"t"`
+}
+
+func main() {
+	j1 := `{"t": "2024-01-01"}`
+	j2 := `{"t": "12:00:00"}`
+	j3 := `{"t": "2024-01-01T12:00:00Z"}`
+
+	var t1, t2, t3 TestStruct
+	fmt.Println("Date:", json.Unmarshal([]byte(j1), &t1))
+	fmt.Println("Time:", json.Unmarshal([]byte(j2), &t2))
+	fmt.Println("Instant:", json.Unmarshal([]byte(j3), &t3))
+}