Add go sdk

performancemetrics/cpu.go

@@ -0,0 +1,26 @@
+package performancemetrics
+
+import (
+	"os"
+	"syscall"
+)
+
+func getCpuTime() (float64, error) {
+	_, err := os.FindProcess(os.Getpid())
+	if err != nil {
+		return 0, err
+	}
+
+	// Use syscall to get CPU times
+	var ru syscall.Rusage
+	err = syscall.Getrusage(syscall.RUSAGE_SELF, &ru)
+	if err != nil {
+		return 0, err
+	}
+
+	// Total CPU time in seconds
+	userSec := float64(ru.Utime.Sec) + float64(ru.Utime.Usec)/1e6
+	sysSec := float64(ru.Stime.Sec) + float64(ru.Stime.Usec)/1e6
+
+	return userSec + sysSec, nil
+}

performancemetrics/disk.go

@@ -0,0 +1,16 @@
+package performancemetrics
+
+import "syscall"
+
+func getDiskUsage(path string) (used, free, total uint64, err error) {
+	var stat syscall.Statfs_t
+	err = syscall.Statfs(path, &stat)
+	if err != nil {
+		return
+	}
+
+	total = stat.Blocks * uint64(stat.Bsize)
+	free = stat.Bfree * uint64(stat.Bsize)
+	used = total - free
+	return
+}

performancemetrics/memory.go

@@ -0,0 +1,9 @@
+package performancemetrics
+
+import "runtime"
+
+func getAllocatedMemory() uint64 {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	return m.Alloc
+}

performancemetrics/model.go

@@ -0,0 +1,15 @@
+package performancemetrics
+
+type PerformanceMetrics struct {
+	Uptime          int64
+	CpuUsage        float64
+	AllocatedMemory uint64
+	GoroutineCount  int
+	DiskUsage       DiskUsage
+}
+
+type DiskUsage struct {
+	Used  uint64
+	Free  uint64
+	Total uint64
+}

performancemetrics/performancemetrics.go

@@ -0,0 +1,108 @@
+package performancemetrics
+
+import (
+	"runtime"
+	"time"
+
+	"github.com/fancyinnovations/fancyanalytics/integrations/go-sdk/client"
+)
+
+type Service struct {
+	appStartTime time.Time
+	lastReset    time.Time
+}
+
+func NewService() *Service {
+	s := &Service{
+		appStartTime: time.Now(),
+	}
+	s.resetMetrics()
+
+	return s
+}
+
+func (s *Service) resetMetrics() {
+	s.lastReset = time.Now()
+}
+
+func (s *Service) collectAndReset() (*PerformanceMetrics, error) {
+	cpuTime, err := getCpuTime()
+	if err != nil {
+		return nil, err
+	}
+	cpuUsage := cpuTime / time.Since(s.lastReset).Seconds()
+
+	goroutineCount := runtime.NumGoroutine()
+
+	allocedMemory := getAllocatedMemory()
+
+	usedDisk, freeDisk, totalDisk, err := getDiskUsage("/")
+	if err != nil {
+		return nil, err
+	}
+
+	uptimeMs := time.Since(s.appStartTime).Milliseconds()
+
+	metrics := &PerformanceMetrics{
+		Uptime:          uptimeMs,
+		CpuUsage:        cpuUsage,
+		AllocatedMemory: allocedMemory,
+		GoroutineCount:  goroutineCount,
+		DiskUsage: DiskUsage{
+			Used:  usedDisk,
+			Free:  freeDisk,
+			Total: totalDisk,
+		},
+	}
+
+	s.resetMetrics()
+
+	return metrics, nil
+}
+
+func (s *Service) MetricProvider() ([]client.RecordData, error) {
+	metrics, err := s.collectAndReset()
+	if err != nil {
+		return nil, err
+	}
+
+	records := []client.RecordData{
+		{
+			Metric: "uptime",
+			Label:  "",
+			Value:  float64(metrics.Uptime),
+		},
+		{
+			Metric: "cpu_usage",
+			Label:  "",
+			Value:  metrics.CpuUsage,
+		},
+		{
+			Metric: "allocated_memory",
+			Label:  "",
+			Value:  float64(metrics.AllocatedMemory),
+		},
+		{
+			Metric: "goroutine_count",
+			Label:  "",
+			Value:  float64(metrics.GoroutineCount),
+		},
+		{
+			Metric: "disk_usage_total",
+			Label:  "",
+			Value:  float64(metrics.DiskUsage.Total),
+		},
+		{
+			Metric: "disk_usage",
+			Label:  "free",
+			Value:  float64(metrics.DiskUsage.Free),
+		},
+		{
+			Metric: "disk_usage",
+			Label:  "used",
+			Value:  float64(metrics.DiskUsage.Used),
+		},
+	}
+
+	return records, nil
+}