Remove snake case, change milliseconds to seconds per standards (#1380)

* Remove snake case, change milliseconds to seconds per standards

* Update to use seconds instead of milliseconds

* Delete old unused function GetTImeDiffSeconds

Author: mccreedy-bitfly

backend/pkg/commons/metrics/metrics.go

@@ -86,20 +86,20 @@ var (
 		Name: "counter",
 		Help: "Generic counter of events with name in labels",
 	}, []string{"name"})
-	NotificationsQueue_Event_Size = promauto.NewGaugeVec(prometheus.GaugeOpts{
+	NotificationsQueueEventSize = promauto.NewGaugeVec(prometheus.GaugeOpts{
 		Name: "notifications_queue_event_size",
 		Help: "Number of notifications in the queue by event type and status",
 	}, []string{"event_type", "status"})
-	NotificationsQueue_Channel_Size = promauto.NewGaugeVec(prometheus.GaugeOpts{
+	NotificationsQueueChannelSize = promauto.NewGaugeVec(prometheus.GaugeOpts{
 		Name: "notifications_queue_channel_size",
 		Help: "Number of notifications in the queue by channel and status",
 	}, []string{"channel", "status"})
-	NotificationsQueue_Pending_Time = promauto.NewHistogramVec(prometheus.HistogramOpts{
-		Name: "notifications_queue_pending_duration_milliseconds",
+	NotificationsQueuePendingTime = promauto.NewHistogramVec(prometheus.HistogramOpts{
+		Name: "notifications_queue_pending_duration_seconds",
 		Help: "How long pending notifications have been in the queue",
 	}, []string{"channel", "event_type"})
-	NotificationsQueue_Sent_Time = promauto.NewHistogramVec(prometheus.HistogramOpts{
-		Name: "notifications_queue_sent_duration_milliseconds",
+	NotificationsQueueSentTime = promauto.NewHistogramVec(prometheus.HistogramOpts{
+		Name: "notifications_queue_sent_duration_seconds",
 		Help: "Amount of time notification took to be successfully sent",
 	}, []string{"channel", "event_type"})
 )

backend/pkg/notification/sending.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"math"
 	"net/http"
 	"net/url"
 	"strings"
@@ -630,39 +629,41 @@ func collectNotificationQueueMetrics() {
 		eventType := GetEventLabelForNotification(notification)
 
 		// Record the amount of time records that were sent (and that still exist in the queue) took to sent
-		metrics.NotificationsQueue_Sent_Time.WithLabelValues(notification.Channel, eventType).Observe(GetTimeDiffMilliseconds(*notification.Sent, *notification.Created))
+		duration := notification.Created.Sub(*notification.Sent).Abs()
+		metrics.NotificationsQueueSentTime.WithLabelValues(notification.Channel, eventType).Observe(duration.Seconds())
 	}
 
 	// Record for each pending notification how long it has been in the queue
 	for _, notification := range pendingNotifications {
 		eventType := GetEventLabelForNotification(notification)
 
 		// Record the amount of time these records have been waiting to been sent
-		metrics.NotificationsQueue_Pending_Time.WithLabelValues(notification.Channel, eventType).Observe(GetTimeDiffMilliseconds(*notification.Created, now))
+		duration := notification.Created.Sub(now).Abs()
+		metrics.NotificationsQueuePendingTime.WithLabelValues(notification.Channel, eventType).Observe(duration.Seconds())
 	}
 
 	// Count number of pending notifications in the queue by event type
 	eventTypeCount := CountByEventType(pendingNotifications)
 	for eventType, numNotifications := range eventTypeCount {
-		metrics.NotificationsQueue_Event_Size.WithLabelValues(eventType, string(Pending)).Set(float64(numNotifications))
+		metrics.NotificationsQueueEventSize.WithLabelValues(eventType, string(Pending)).Set(float64(numNotifications))
 	}
 
 	// Count number of sent notifications in the queue by event type
 	eventTypeCount = CountByEventType(sentNotifications)
 	for eventType, numNotifications := range eventTypeCount {
-		metrics.NotificationsQueue_Event_Size.WithLabelValues(eventType, string(Sent)).Set(float64(numNotifications))
+		metrics.NotificationsQueueEventSize.WithLabelValues(eventType, string(Sent)).Set(float64(numNotifications))
 	}
 
 	// Count number of pending notifications in the queue by channel
 	channelCount := CountByChannel(pendingNotifications)
 	for channelType, numNotifications := range channelCount {
-		metrics.NotificationsQueue_Channel_Size.WithLabelValues(channelType, string(Pending)).Set(float64(numNotifications))
+		metrics.NotificationsQueueChannelSize.WithLabelValues(channelType, string(Pending)).Set(float64(numNotifications))
 	}
 
 	// Count number of sent notifications in the queue by channel
 	channelCount = CountByChannel(sentNotifications)
 	for channelType, numNotifications := range channelCount {
-		metrics.NotificationsQueue_Channel_Size.WithLabelValues(channelType, string(Sent)).Set(float64(numNotifications))
+		metrics.NotificationsQueueChannelSize.WithLabelValues(channelType, string(Sent)).Set(float64(numNotifications))
 	}
 }
 
@@ -736,12 +737,3 @@ func CountByChannel(notifications []Notification) map[string]int {
 	}
 	return channelCountMap
 }
-
-/**
- * Returns the amount of milliseconds between two timestamps. Always returns a positive
- * duration, so you don't have to worry about date ordering
- */
-func GetTimeDiffMilliseconds(time1 time.Time, time2 time.Time) float64 {
-	duration := time1.Sub(time2)
-	return math.Abs(float64(duration.Milliseconds()))
-}

backend/pkg/notification/sending_test.go

@@ -2,42 +2,11 @@ package notification
 
 import (
 	"testing"
-	"time"
 
 	"github.com/gobitfly/beaconchain/pkg/commons/types"
 	"github.com/google/go-cmp/cmp"
 )
 
-// getTimeDiffMilliseconds - Positive diff
-// getTimeDiffMilliseconds - Negative diff
-// countByChannel - All Notifications, no notifications, unknown notification type
-//
-// countByEventType
-// extractEventTypeFromNotification - All event types, grab from DB
-
-func TestGetTimeDiffMilliseconds(t *testing.T) {
-	tests := map[string]struct {
-		time1 time.Time
-		time2 time.Time
-		want  float64
-	}{
-		"no time difference":         {time1: time.UnixMilli(9000000000), time2: time.UnixMilli(9000000000), want: 0.0},
-		"positive time difference":   {time1: time.UnixMilli(9000001000), time2: time.UnixMilli(9000000000), want: 1000.0},
-		"negative time difference":   {time1: time.UnixMilli(9000000000), time2: time.UnixMilli(9000001000), want: 1000.0},
-		"sub-second time difference": {time1: time.UnixMilli(9000001000), time2: time.UnixMilli(9000000500), want: 500.0},
-	}
-
-	for name, tc := range tests {
-		t.Run(name, func(t *testing.T) {
-			got := GetTimeDiffMilliseconds(tc.time1, tc.time2)
-			diff := cmp.Diff(tc.want, got)
-			if diff != "" {
-				t.Fatal(diff)
-			}
-		})
-	}
-}
-
 func TestExtractEventNameStringFromNotificationForMetrics(t *testing.T) {
 	tests := map[string]struct {
 		notification Notification