Skip to content

The only tool you need to know what is happening and how to fix it.

feat added better reporting

ddux5bc250908105
diff --git a/backend/app/controllers/exception_stack_trace.controller.go b/backend/app/controllers/exception_stack_trace.controller.go
new file mode 100644
index 00000000..d1dd800f
--- /dev/null
+++ b/backend/app/controllers/exception_stack_trace.controller.go
@@ -0,0 +1,45 @@
+package controllers
+
+import (
+ "backend/app/models"
+ "backend/app/repositories"
+ "net/http"
+ "time"
+
+ "github.com/gin-gonic/gin"
+)
+
+type exceptionStackTraceController struct{}
+
+type ExceptionSearchRequest struct {
+ FromDate time.Time `json:"fromDate"`
+ ToDate time.Time `json:"toDate"`
+ OrderBy string `json:"orderBy"`
+ Pagination PaginationParams `json:"pagination"`
+}
+
+func (e exceptionStackTraceController) FindGrouppedExceptionStackTraces(c *gin.Context) {
+ var request ExceptionSearchRequest
+ if err := c.ShouldBindJSON(&request); err != nil {
+ c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ exceptions, total, err := repositories.ExceptionStackTraceRepository.FindGrouped(c, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+
+ c.JSON(http.StatusOK, PaginatedResponse[models.ExceptionGroup]{
+ Data: exceptions,
+ Pagination: Pagination{
+ Page: request.Pagination.Page,
+ PageSize: request.Pagination.PageSize,
+ Total: total,
+ TotalPages: (total + int64(request.Pagination.PageSize) - 1) / int64(request.Pagination.PageSize),
+ },
+ })
+}
+
+var ExceptionStackTraceController = exceptionStackTraceController{}
diff --git a/backend/app/controllers/metric_record.controller.go b/backend/app/controllers/metric_record.controller.go
index 976f3007..30df6b1a 100644
--- a/backend/app/controllers/metric_record.controller.go
+++ b/backend/app/controllers/metric_record.controller.go
@@ -1,6 +1,11 @@
package controllers
import (
+ "backend/app/models"
+ "backend/app/repositories"
+ "net/http"
+ "time"
+
"github.com/gin-gonic/gin"
)
@@ -8,10 +13,100 @@ type metricRecordController struct{}
func (e metricRecordController) FindHomepageStats(c *gin.Context) {
// requests in last 24h vs previous 24h
- // exceptions in last 24h vs previous 24h
+ now := time.Now()
+ oneDayAgo := now.Add(-24 * time.Hour)
+ twoDaysAgo := now.Add(-48 * time.Hour)
+
+ // requests
+ requestsNow, err := repositories.TransactionRepository.CountBetween(c, oneDayAgo, now)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+ requestsPrev, err := repositories.TransactionRepository.CountBetween(c, twoDaysAgo, oneDayAgo)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+
+ // exceptions
+ exceptionsNow, err := repositories.ExceptionStackTraceRepository.CountBetween(c, oneDayAgo, now)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+ exceptionsPrev, err := repositories.ExceptionStackTraceRepository.CountBetween(c, twoDaysAgo, oneDayAgo)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+
// ram usage last 24h vs previous 24h
+ ramNow, err := repositories.MetricRecordRepository.GetAverageBetween(c, models.MetricNameMemoryUsage, oneDayAgo, now)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+ ramPrev, err := repositories.MetricRecordRepository.GetAverageBetween(c, models.MetricNameMemoryUsage, twoDaysAgo, oneDayAgo)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+
// memory usage last 24h vs previous 24h
+ cpuNow, err := repositories.MetricRecordRepository.GetAverageBetween(c, models.MetricNameCpuUsage, oneDayAgo, now)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+ cpuPrev, err := repositories.MetricRecordRepository.GetAverageBetween(c, models.MetricNameCpuUsage, twoDaysAgo, oneDayAgo)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+
+ c.JSON(http.StatusOK, HomepageStatsResponse{
+ Requests: StatsComparison{
+ Current: float64(requestsNow),
+ Previous: float64(requestsPrev),
+ PercentChange: calculatePercentChange(float64(requestsNow), float64(requestsPrev)),
+ },
+ Exceptions: StatsComparison{
+ Current: float64(exceptionsNow),
+ Previous: float64(exceptionsPrev),
+ PercentChange: calculatePercentChange(float64(exceptionsNow), float64(exceptionsPrev)),
+ },
+ MemoryUsage: StatsComparison{
+ Current: ramNow,
+ Previous: ramPrev,
+ PercentChange: calculatePercentChange(ramNow, ramPrev),
+ },
+ CpuUsage: StatsComparison{
+ Current: cpuNow,
+ Previous: cpuPrev,
+ PercentChange: calculatePercentChange(cpuNow, cpuPrev),
+ },
+ })
+}
+
+type HomepageStatsResponse struct {
+ Requests StatsComparison `json:"requests"`
+ Exceptions StatsComparison `json:"exceptions"`
+ MemoryUsage StatsComparison `json:"memoryUsage"`
+ CpuUsage StatsComparison `json:"cpuUsage"`
+}
+
+type StatsComparison struct {
+ Current float64 `json:"current"`
+ Previous float64 `json:"previous"`
+ PercentChange float64 `json:"percentChange"`
+}
+func calculatePercentChange(current, previous float64) float64 {
+ if previous == 0 {
+ return 0
+ }
+ return ((current - previous) / previous) * 100
}
var MetricRecordController = metricRecordController{}
diff --git a/backend/app/controllers/routes.go b/backend/app/controllers/routes.go
index 3bbfd320..27291b57 100644
--- a/backend/app/controllers/routes.go
+++ b/backend/app/controllers/routes.go
@@ -29,6 +29,6 @@ func RegisterControllers(router *gin.RouterGroup) {
router.POST("/stats", middleware.UseAppAuth, middleware.UseGzip, MetricRecordController.FindHomepageStats)
- // router.POST("/transactions", middleware.UseAppAuth, middleware.UseGzip, TransactionController.FindAllTransactions)
- // router.POST("/exception-stack-traces", middleware.UseAppAuth, middleware.UseGzip, AppController.FindAllExceptionStackTraces)
+ router.POST("/transactions", middleware.UseAppAuth, middleware.UseGzip, TransactionController.FindAllTransactions)
+ router.POST("/exception-stack-traces", middleware.UseAppAuth, middleware.UseGzip, ExceptionStackTraceController.FindGrouppedExceptionStackTraces)
}
diff --git a/backend/app/controllers/transaction.controller.go b/backend/app/controllers/transaction.controller.go
new file mode 100644
index 00000000..7fd80550
--- /dev/null
+++ b/backend/app/controllers/transaction.controller.go
@@ -0,0 +1,45 @@
+package controllers
+
+import (
+ "backend/app/models"
+ "backend/app/repositories"
+ "net/http"
+ "time"
+
+ "github.com/gin-gonic/gin"
+)
+
+type transactionController struct{}
+
+type TransactionSearchRequest struct {
+ FromDate time.Time `json:"fromDate"`
+ ToDate time.Time `json:"toDate"`
+ OrderBy string `json:"orderBy"`
+ Pagination PaginationParams `json:"pagination"`
+}
+
+func (e transactionController) FindAllTransactions(c *gin.Context) {
+ var request TransactionSearchRequest
+ if err := c.ShouldBindJSON(&request); err != nil {
+ c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ transactions, total, err := repositories.TransactionRepository.FindAll(c, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+
+ c.JSON(http.StatusOK, PaginatedResponse[models.Transaction]{
+ Data: transactions,
+ Pagination: Pagination{
+ Page: request.Pagination.Page,
+ PageSize: request.Pagination.PageSize,
+ Total: total,
+ TotalPages: (total + int64(request.Pagination.PageSize) - 1) / int64(request.Pagination.PageSize),
+ },
+ })
+}
+
+var TransactionController = transactionController{}
diff --git a/backend/app/middleware/use_app_auth.middleware copy.go b/backend/app/middleware/use_app_auth.middleware copy.go
index c9c28d04..c41743a4 100644
--- a/backend/app/middleware/use_app_auth.middleware copy.go
+++ b/backend/app/middleware/use_app_auth.middleware copy.go
@@ -10,7 +10,7 @@ import (
var UseAppAuth func(c *gin.Context)
func InitUseAppAuth() {
- authHeader := "Bearer " + os.Getenv("TOKEN")
+ authHeader := "Bearer " + os.Getenv("APP_TOKEN")
UseAppAuth = func(c *gin.Context) {
if authHeader != c.GetHeader("Authorization") {
diff --git a/backend/app/migrations/ch/0001_init.up.sql b/backend/app/migrations/ch/0001_init.up.sql
new file mode 100644
index 00000000..8ada6f52
--- /dev/null
+++ b/backend/app/migrations/ch/0001_init.up.sql
@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS transactions (
+ id String,
+ endpoint String,
+ duration Int64,
+ recorded_at DateTime,
+ status_code Int32,
+ body_size Int32,
+ client_ip String
+) ENGINE = MergeTree()
+PARTITION BY toYYYYMM(recorded_at)
+ORDER BY (recorded_at, endpoint);
diff --git a/backend/app/migrations/ch/0002_init.up.sql b/backend/app/migrations/ch/0002_init.up.sql
new file mode 100644
index 00000000..3c1b81b1
--- /dev/null
+++ b/backend/app/migrations/ch/0002_init.up.sql
@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS metric_records (
+ name String,
+ value Float32,
+ recorded_at DateTime
+) ENGINE = MergeTree()
+PARTITION BY toYYYYMM(recorded_at)
+ORDER BY (recorded_at, name);
diff --git a/backend/app/migrations/ch/0003_init.up.sql b/backend/app/migrations/ch/0003_init.up.sql
new file mode 100644
index 00000000..5168ab6e
--- /dev/null
+++ b/backend/app/migrations/ch/0003_init.up.sql
@@ -0,0 +1,9 @@
+
+CREATE TABLE IF NOT EXISTS exception_stack_traces (
+ transaction_id Nullable(String),
+ exception_hash String,
+ stack_trace String,
+ recorded_at DateTime
+) ENGINE = MergeTree()
+PARTITION BY toYYYYMM(recorded_at)
+ORDER BY (recorded_at, exception_hash);
diff --git a/backend/app/migrations/migrations.go b/backend/app/migrations/migrations.go
new file mode 100644
index 00000000..97aa7bc1
--- /dev/null
+++ b/backend/app/migrations/migrations.go
@@ -0,0 +1,53 @@
+package migrations
+
+import (
+ "database/sql"
+ "embed"
+ "fmt"
+ "os"
+
+ "github.com/golang-migrate/migrate/v4"
+ migrateCh "github.com/golang-migrate/migrate/v4/database/clickhouse"
+ "github.com/golang-migrate/migrate/v4/source/iofs"
+)
+
+//go:embed ch/*.sql
+var migrationsChFS embed.FS
+
+func runMigrationsClickhouse(connStr string) error {
+ db, err := sql.Open("clickhouse", connStr)
+ if err != nil {
+ return err
+ }
+ defer db.Close()
+
+ source, err := iofs.New(migrationsChFS, "ch")
+ if err != nil {
+ return err
+ }
+
+ driver, err := migrateCh.WithInstance(db, &migrateCh.Config{})
+ if err != nil {
+ return err
+ }
+
+ m, err := migrate.NewWithInstance("iofs", source, "clickhouse", driver)
+ if err != nil {
+ return err
+ }
+
+ if err := m.Up(); err != nil && err != migrate.ErrNoChange {
+ return err
+ }
+
+ return nil
+}
+
+func Run() error {
+ clickhouseServer := os.Getenv("CLICKHOUSE_SERVER")
+ clickhouseDatabase := os.Getenv("CLICKHOUSE_DATABASE")
+ clickhouseUsername := os.Getenv("CLICKHOUSE_USERNAME")
+ clickhousePassword := os.Getenv("CLICKHOUSE_PASSWORD")
+
+ return runMigrationsClickhouse(fmt.Sprintf(`clickhouse://%s?username=%s&password=%s&database=%s`, clickhouseServer, clickhouseUsername, clickhousePassword, clickhouseDatabase))
+}
diff --git a/backend/app/models/exception_stack_trace.model.go b/backend/app/models/exception_stack_trace.model.go
index 5be0c612..1a80f4aa 100644
--- a/backend/app/models/exception_stack_trace.model.go
+++ b/backend/app/models/exception_stack_trace.model.go
@@ -8,3 +8,11 @@ type ExceptionStackTrace struct {
StackTrace string `json:"stackTrace" ch:"stack_trace"`
RecordedAt time.Time `json:"recordedAt" ch:"recorded_at"`
}
+
+type ExceptionGroup struct {
+ ExceptionHash string `json:"exceptionHash" ch:"exception_hash"`
+ StackTrace string `json:"stackTrace" ch:"stack_trace"`
+ LastSeen time.Time `json:"lastSeen" ch:"last_seen"`
+ FirstSeen time.Time `json:"firstSeen" ch:"first_seen"`
+ Count uint64 `json:"count" ch:"count"`
+}
diff --git a/backend/app/models/metric_record.model.go b/backend/app/models/metric_record.model.go
index 51c47e9e..aa53282a 100644
--- a/backend/app/models/metric_record.model.go
+++ b/backend/app/models/metric_record.model.go
@@ -7,3 +7,8 @@ type MetricRecord struct {
Value float32 `json:"value" ch:"value"`
RecordedAt time.Time `json:"recordedAt" ch:"recorded_at"`
}
+
+const (
+ MetricNameMemoryUsage = "memory_usage"
+ MetricNameCpuUsage = "cpu_usage"
+)
diff --git a/backend/app/repositories/exception_stack_trace.repository.go b/backend/app/repositories/exception_stack_trace.repository.go
index 9a969d58..ddfc2f28 100644
--- a/backend/app/repositories/exception_stack_trace.repository.go
+++ b/backend/app/repositories/exception_stack_trace.repository.go
@@ -4,6 +4,7 @@ import (
"backend/app/chdb"
"backend/app/models"
"context"
+ "time"
)
type exceptionStackTraceRepository struct{}
@@ -21,4 +22,51 @@ func (e *exceptionStackTraceRepository) InsertAsync(ctx context.Context, lines [
return batch.Send()
}
+func (e *exceptionStackTraceRepository) CountBetween(ctx context.Context, start, end time.Time) (int64, error) {
+ var count uint64
+ err := (*chdb.Conn).QueryRow(ctx, "SELECT count() FROM exception_stack_traces WHERE recorded_at >= ? AND recorded_at <= ?", start, end).Scan(&count)
+ return int64(count), err
+}
+
+func (e *exceptionStackTraceRepository) FindGrouped(ctx context.Context, fromDate, toDate time.Time, page, pageSize int, orderBy string) ([]models.ExceptionGroup, int64, error) {
+ // Count unique hashes
+ var count uint64
+ err := (*chdb.Conn).QueryRow(ctx, "SELECT uniq(exception_hash) FROM exception_stack_traces WHERE recorded_at >= ? AND recorded_at <= ?", fromDate, toDate).Scan(&count)
+ if err != nil {
+ return nil, 0, err
+ }
+
+ offset := (page - 1) * pageSize
+
+ allowedOrderBy := map[string]bool{
+ "last_seen": true,
+ "first_seen": true,
+ "count": true,
+ }
+
+ if !allowedOrderBy[orderBy] {
+ orderBy = "count"
+ }
+
+ // Re-writing query string construction for OrderBy to avoid binding issue
+ fullQuery := "SELECT exception_hash, any(stack_trace), max(recorded_at) as last_seen, min(recorded_at) as first_seen, count() as count FROM exception_stack_traces WHERE recorded_at >= ? AND recorded_at <= ? GROUP BY exception_hash ORDER BY " + orderBy + " DESC LIMIT ? OFFSET ?"
+
+ rows, err := (*chdb.Conn).Query(ctx, fullQuery, fromDate, toDate, pageSize, offset)
+ if err != nil {
+ return nil, 0, err
+ }
+ defer rows.Close()
+
+ var groups []models.ExceptionGroup
+ for rows.Next() {
+ var g models.ExceptionGroup
+ if err := rows.Scan(&g.ExceptionHash, &g.StackTrace, &g.LastSeen, &g.FirstSeen, &g.Count); err != nil {
+ return nil, 0, err
+ }
+ groups = append(groups, g)
+ }
+
+ return groups, int64(count), nil
+}
+
var ExceptionStackTraceRepository = exceptionStackTraceRepository{}
diff --git a/backend/app/repositories/metric_record.repository.go b/backend/app/repositories/metric_record.repository.go
index 511a4ee1..43ad321b 100644
--- a/backend/app/repositories/metric_record.repository.go
+++ b/backend/app/repositories/metric_record.repository.go
@@ -4,6 +4,7 @@ import (
"backend/app/chdb"
"backend/app/models"
"context"
+ "time"
)
type metricRecordRepository struct{}
@@ -21,4 +22,10 @@ func (e *metricRecordRepository) InsertAsync(ctx context.Context, lines []models
return batch.Send()
}
+func (e *metricRecordRepository) GetAverageBetween(ctx context.Context, name string, start, end time.Time) (float64, error) {
+ var avg float64
+ err := (*chdb.Conn).QueryRow(ctx, "SELECT coalesce(avg(value), 0) FROM metric_records WHERE name = ? AND recorded_at >= ? AND recorded_at <= ?", name, start, end).Scan(&avg)
+ return avg, err
+}
+
var MetricRecordRepository = metricRecordRepository{}
diff --git a/backend/app/repositories/transaction.repository.go b/backend/app/repositories/transaction.repository.go
index da60dc5d..a84d1cd7 100644
--- a/backend/app/repositories/transaction.repository.go
+++ b/backend/app/repositories/transaction.repository.go
@@ -4,6 +4,7 @@ import (
"backend/app/chdb"
"backend/app/models"
"context"
+ "time"
)
type transactionRepository struct{}
@@ -21,4 +22,49 @@ func (e *transactionRepository) InsertAsync(ctx context.Context, lines []models.
return batch.Send()
}
+func (e *transactionRepository) CountBetween(ctx context.Context, start, end time.Time) (int64, error) {
+ var count uint64
+ err := (*chdb.Conn).QueryRow(ctx, "SELECT count() FROM transactions WHERE recorded_at >= ? AND recorded_at <= ?", start, end).Scan(&count)
+ return int64(count), err
+}
+
+func (e *transactionRepository) FindAll(ctx context.Context, fromDate, toDate time.Time, page, pageSize int, orderBy string) ([]models.Transaction, int64, error) {
+ var count uint64
+ err := (*chdb.Conn).QueryRow(ctx, "SELECT count() FROM transactions WHERE recorded_at >= ? AND recorded_at <= ?", fromDate, toDate).Scan(&count)
+ if err != nil {
+ return nil, 0, err
+ }
+
+ offset := (page - 1) * pageSize
+
+ allowedOrderBy := map[string]bool{
+ "recorded_at": true,
+ "duration": true,
+ "status_code": true,
+ "body_size": true,
+ }
+
+ if !allowedOrderBy[orderBy] {
+ orderBy = "recorded_at"
+ }
+
+ query := "SELECT id, endpoint, duration, recorded_at, status_code, body_size, client_ip FROM transactions WHERE recorded_at >= ? AND recorded_at <= ? ORDER BY " + orderBy + " DESC LIMIT ? OFFSET ?"
+ rows, err := (*chdb.Conn).Query(ctx, query, fromDate, toDate, pageSize, offset)
+ if err != nil {
+ return nil, 0, err
+ }
+ defer rows.Close()
+
+ var transactions []models.Transaction
+ for rows.Next() {
+ var t models.Transaction
+ if err := rows.Scan(&t.Id, &t.Endpoint, &t.Duration, &t.RecordedAt, &t.StatusCode, &t.BodySize, &t.ClientIP); err != nil {
+ return nil, 0, err
+ }
+ transactions = append(transactions, t)
+ }
+
+ return transactions, int64(count), nil
+}
+
var TransactionRepository = transactionRepository{}
diff --git a/backend/main.go b/backend/main.go
index b1a38a11..a2996e4a 100644
--- a/backend/main.go
+++ b/backend/main.go
@@ -4,6 +4,7 @@ import (
"backend/app/chdb"
"backend/app/controllers"
"backend/app/middleware"
+ "backend/app/migrations"
"log"
"github.com/gin-gonic/gin"
@@ -16,7 +17,15 @@ func main() {
log.Fatal("Error loading .env file")
}
- chdb.Init()
+ err = chdb.Init()
+ if err != nil {
+ panic(err)
+ }
+
+ err = migrations.Run()
+ if err != nil {
+ panic(err)
+ }
middleware.InitUseClientAuth()
diff --git a/clients/go-client/traceway.go b/clients/go-client/traceway.go
index 8f39aeec..db00c9d1 100644
--- a/clients/go-client/traceway.go
+++ b/clients/go-client/traceway.go
@@ -109,13 +109,15 @@ const (
CollectionFrameMessageTypeException = 0
CollectionFrameMessageTypeMetric = 1
CollectionFrameMessageTypeTransaction = 2
+ CollectionFrameMessageTypeClearFrames = 3
)
type CollectionFrameMessage struct {
- msgType collectionFrameMessageType
- exceptionStackTrace *ExceptionStackTrace
- metric *MetricsRecord
- transaction *Transaction
+ msgType collectionFrameMessageType
+ exceptionStackTrace *ExceptionStackTrace
+ metric *MetricsRecord
+ transaction *Transaction
+ collectionFramesToRemove []*CollectionFrame
}
type CollectionFrameStore struct {
@@ -185,18 +187,20 @@ func (s *CollectionFrameStore) process() {
case <-s.stopCh:
return
case <-rotationTicker.C:
- fmt.Println("TRIGGERING THE rotationTicker.C")
if s.current != nil {
if s.currentSetAt.Before(time.Now().Add(-s.collectionInterval)) {
- fmt.Println("ROTATING AND PROCESSING")
s.rotateCurrentCollectionFrame()
s.processSendQueue()
}
} else if s.sendQueue.len > 0 {
- fmt.Println("PROCESSING SEND QUEUE")
s.processSendQueue()
}
case msg := <-s.messageQueue:
+ if msg.msgType == CollectionFrameMessageTypeClearFrames {
+ s.sendQueue.Remove(msg.collectionFramesToRemove)
+ continue
+ }
+
if s.current == nil {
// we need to start a new frame
s.current = &CollectionFrame{}
@@ -219,10 +223,8 @@ func (s *CollectionFrameStore) rotateCurrentCollectionFrame() {
s.current = nil
}
func (s *CollectionFrameStore) processSendQueue() {
- fmt.Println("processSendQueue")
// we are triggering an upload - we need to make sure no other uploads are going on
if s.lastUploadStarted == nil || s.lastUploadStarted.Before(time.Now().Add(s.uploadTimeout)) {
- fmt.Println("ABOUT TO TRIGGER THE UPLOAD")
now := time.Now()
s.lastUploadStarted = &now
go s.triggerUpload(s.sendQueue.ReadAll())
@@ -231,7 +233,6 @@ func (s *CollectionFrameStore) processSendQueue() {
// Report adds an exception event to the current envelope
func (s *CollectionFrameStore) triggerUpload(framesToSend []*CollectionFrame) {
- fmt.Println("TRIGGER UPLOAD STARTED")
defer func() {
if r := recover(); s.debug && r != nil {
log.Print("Traceway: failed to upload the CollectionFrame")
@@ -241,8 +242,8 @@ func (s *CollectionFrameStore) triggerUpload(framesToSend []*CollectionFrame) {
}()
jsonData, err := json.Marshal(gin.H{
- "app": s.app,
- "frames": framesToSend,
+ "app": s.app,
+ "collectionFrames": framesToSend,
})
if err != nil {
if s.debug {
@@ -251,8 +252,6 @@ func (s *CollectionFrameStore) triggerUpload(framesToSend []*CollectionFrame) {
return
}
- fmt.Println("SENDING POST TO ", s.apiUrl, string(jsonData))
-
var buf bytes.Buffer
gz := gzip.NewWriter(&buf)
if _, err := gz.Write(jsonData); err != nil {
@@ -290,7 +289,13 @@ func (s *CollectionFrameStore) triggerUpload(framesToSend []*CollectionFrame) {
}
defer resp.Body.Close()
- fmt.Println("RESPONDED WITH", resp.StatusCode)
+ if resp.StatusCode == 200 {
+ // we need to clear out the frames
+ s.messageQueue <- CollectionFrameMessage{
+ msgType: CollectionFrameMessageTypeClearFrames,
+ collectionFramesToRemove: framesToSend,
+ }
+ }
}
var collectionFrameStore *CollectionFrameStore
diff --git a/clients/go-client/traceway_gin/traceway_gin.go b/clients/go-client/traceway_gin/traceway_gin.go
index 9549542e..4080d27d 100644
--- a/clients/go-client/traceway_gin/traceway_gin.go
+++ b/clients/go-client/traceway_gin/traceway_gin.go
@@ -1,7 +1,6 @@
package tracewaygin
import (
- "fmt"
"time"
"traceway"
@@ -12,14 +11,11 @@ import (
func wrapAndExecute(c *gin.Context) (s *string) {
defer func() {
if r := recover(); r != nil {
- fmt.Println("RECOVERING")
m := traceway.FormatRWithStack(r, traceway.CaptureStack(2))
s = &m
}
}()
- fmt.Println("A1")
c.Next()
- fmt.Println("A2")
return nil
}
@@ -27,7 +23,6 @@ func New(app, connectionString string, options ...func(*traceway.TracewayOptions
traceway.Init(app, connectionString, options...)
return func(c *gin.Context) {
- fmt.Println("INTERCEPTED")
start := time.Now()
path := c.Request.URL.Path
@@ -51,12 +46,9 @@ func New(app, connectionString string, options ...func(*traceway.TracewayOptions
defer recover()
- fmt.Println("HERE")
traceway.CaptureTransaction(transactionId, transactionEndpoint, duration, start, statusCode, bodySize, clientIP)
- fmt.Println("HERE2")
if stackTraceFormatted != nil {
- fmt.Println("HERE3")
traceway.CaptureTransactionException(transactionId, *stackTraceFormatted)
}
}
diff --git a/clients/go-client/typed_ring.go b/clients/go-client/typed_ring.go
index 1ec15040..ed8efdd7 100644
--- a/clients/go-client/typed_ring.go
+++ b/clients/go-client/typed_ring.go
@@ -13,6 +13,7 @@ func InitTypedRing[T *E, E any](capacity int) TypedRing[T, E] {
capacity: capacity,
}
}
+
func (t *TypedRing[T, E]) Push(val T) {
t.arr[t.head] = val
t.head = (t.head + 1) % t.capacity
@@ -20,6 +21,7 @@ func (t *TypedRing[T, E]) Push(val T) {
t.len += 1
}
}
+
func (t *TypedRing[T, E]) ReadAll() []T {
result := make([]T, t.len)
for i := 0; i < t.len; i++ {
@@ -28,6 +30,7 @@ func (t *TypedRing[T, E]) ReadAll() []T {
}
return result
}
+
func (t *TypedRing[T, E]) Clear() {
for i := range t.arr {
t.arr[i] = nil
@@ -35,3 +38,39 @@ func (t *TypedRing[T, E]) Clear() {
t.head = 0
t.len = 0
}
+
+func (t *TypedRing[T, E]) Remove(vals []T) int {
+ if len(vals) == 0 {
+ return 0
+ }
+
+ toRemove := make(map[T]struct{}, len(vals))
+ for _, v := range vals {
+ toRemove[v] = struct{}{}
+ }
+
+ writeIdx := 0
+ removed := 0
+ for i := 0; i < t.len; i++ {
+ readIdx := (t.head - t.len + i + t.capacity) % t.capacity
+ if _, shouldRemove := toRemove[t.arr[readIdx]]; shouldRemove {
+ removed++
+ } else {
+ if writeIdx != i {
+ destIdx := (t.head - t.len + writeIdx + t.capacity) % t.capacity
+ t.arr[destIdx] = t.arr[readIdx]
+ }
+ writeIdx++
+ }
+ }
+
+ for i := writeIdx; i < t.len; i++ {
+ idx := (t.head - t.len + i + t.capacity) % t.capacity
+ t.arr[idx] = nil
+ }
+
+ t.len = writeIdx
+ t.head = (t.head - removed + t.capacity) % t.capacity
+
+ return removed
+}