mastodon/relay
1
0
Fork 0
mirror of https://git.ptzo.gdn/feditools/relay.git synced 2024-09-21 11:47:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Metrics Improvements (#65)

Browse Source 
* fix for no metrics
* improvements
This commit is contained in:
Tyr Mactire 2022-08-12 12:11:10 -07:00 committed by GitHub
parent e86ff62e7c
commit 2f5a23288a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 212 additions and 365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
internal/http/webapp/admin_instance_view.go
View File

@ -168,28 +168,28 @@ new Chart(document.getElementById("receiveChartContainer"), {
});
`
func JSAdminInstanceView(deliverErrors, deliverSuccess, receive *logic.MetricsDataPointsTime) string {
labelsLen := len(*deliverErrors)
func JSAdminInstanceView(deliverErrors, deliverSuccess, receive logic.MetricsDataPointsTime) string {
labelsLen := len(deliverErrors)
labels := make([]string, labelsLen)
for i, dp := range *deliverErrors {
for i, dp := range deliverErrors {
labels[labelsLen-1-i] = dp.X.Format("\"Jan 02 2006\"")
}
deliverErrorsLen := len(*deliverErrors)
deliverErrorsLen := len(deliverErrors)
deliverErrorsData := make([]string, deliverErrorsLen)
for i, dp := range *deliverErrors {
for i, dp := range deliverErrors {
deliverErrorsData[deliverErrorsLen-1-i] = strconv.FormatInt(int64(dp.Y), 10)
}
deliverSuccessLen := len(*deliverSuccess)
deliverSuccessLen := len(deliverSuccess)
deliverSuccessData := make([]string, deliverSuccessLen)
for i, dp := range *deliverSuccess {
for i, dp := range deliverSuccess {
deliverSuccessData[deliverSuccessLen-1-i] = strconv.FormatInt(int64(dp.Y), 10)
}
receiveLen := len(*receive)
receiveLen := len(receive)
receiveData := make([]string, receiveLen)
for i, dp := range *receive {
for i, dp := range receive {
receiveData[receiveLen-1-i] = strconv.FormatInt(int64(dp.Y), 10)
}

17
internal/http/webapp/home.go
View File

@ -113,17 +113,16 @@ new Chart(document.getElementById("receiveChartContainer"), {
});
`
func JSHome(receive *logic.MetricsDataPointsTime) string {
labelsLen := len(*receive)
labels := make([]string, labelsLen)
for i, dp := range *receive {
labels[labelsLen-1-i] = dp.X.Format("\"Jan 02 2006\"")
}
func JSHome(receive logic.MetricsDataPointsTime) string {
receiveLen := len(receive)
receiveLen := len(*receive)
labels := make([]string, receiveLen)
receiveData := make([]string, receiveLen)
for i, dp := range *receive {
receiveData[receiveLen-1-i] = strconv.FormatInt(int64(dp.Y), 10)
for i, dp := range receive {
j := receiveLen - 1 - i
labels[j] = dp.X.Format("\"Jan 02 2006\"")
receiveData[j] = strconv.FormatInt(int64(dp.Y), 10)
}
return fmt.Sprintf(

17
internal/kv/kv.go
View File

@ -13,13 +13,6 @@ type KV interface {
}
type Metrics interface {
GetMetricsDeliverError(ctx context.Context, instanceID int64, timestamp time.Time) (int, Error)
GetMetricsDeliverErrorTotal(ctx context.Context, timestamp time.Time) (int, Error)
GetMetricsDeliverSuccess(ctx context.Context, instanceID int64, timestamp time.Time) (int, Error)
GetMetricsDeliverSuccessTotal(ctx context.Context, timestamp time.Time) (int, Error)
GetMetricsReceived(ctx context.Context, instanceID int64, timestamp time.Time) (int, Error)
GetMetricsReceivedTotal(ctx context.Context, timestamp time.Time) (int, Error)
IncMetricsDeliverError(ctx context.Context, instanceID int64, timestamp time.Time) Error
IncMetricsDeliverErrorTotal(ctx context.Context, timestamp time.Time) Error
IncMetricsDeliverSuccess(ctx context.Context, instanceID int64, timestamp time.Time) Error
@ -27,7 +20,11 @@ type Metrics interface {
IncMetricsReceived(ctx context.Context, instanceID int64, timestamp time.Time) Error
IncMetricsReceivedTotal(ctx context.Context, timestamp time.Time) Error
MGetAllMetricsDeliverError(ctx context.Context, timestamps []time.Time) (*map[int64]map[time.Time]int, Error)
MGetAllMetricsDeliverSuccess(ctx context.Context, timestamps []time.Time) (*map[int64]map[time.Time]int, Error)
MGetAllMetricsReceived(ctx context.Context, timestamps []time.Time) (*map[int64]map[time.Time]int, Error)
MGetMetricsDeliverError(ctx context.Context, instanceID int64, timestamps []time.Time) (map[time.Time]int, Error)
MGetAllMetricsDeliverError(ctx context.Context, timestamps []time.Time) (map[int64]map[time.Time]int, Error)
MGetMetricsDeliverSuccess(ctx context.Context, instanceID int64, timestamps []time.Time) (map[time.Time]int, Error)
MGetAllMetricsDeliverSuccess(ctx context.Context, timestamps []time.Time) (map[int64]map[time.Time]int, Error)
MGetMetricsReceived(ctx context.Context, instanceID int64, timestamps []time.Time) (map[time.Time]int, Error)
MGetMetricsReceivedTotal(ctx context.Context, timestamps []time.Time) (map[time.Time]int, Error)
MGetAllMetricsReceived(ctx context.Context, timestamps []time.Time) (map[int64]map[time.Time]int, Error)
}

253
internal/kv/redis/metrics.go
View File

@ -8,60 +8,6 @@ import (
"time"
)
func (c *Client) GetMetricsDeliverError(ctx context.Context, instanceID int64, timestamp time.Time) (int, kv.Error) {
count, err := c.redis.HGet(ctx, kv.KeyMetricsDeliverError(timestamp), strconv.FormatInt(instanceID, 10)).Int()
if err != nil {
return 0, c.ProcessError(err)
}
return count, nil
}
func (c *Client) GetMetricsDeliverErrorTotal(ctx context.Context, timestamp time.Time) (int, kv.Error) {
count, err := c.redis.Get(ctx, kv.KeyMetricsDeliverErrorTotal(timestamp)).Int()
if err != nil {
return 0, c.ProcessError(err)
}
return count, nil
}
func (c *Client) GetMetricsDeliverSuccess(ctx context.Context, instanceID int64, timestamp time.Time) (int, kv.Error) {
count, err := c.redis.HGet(ctx, kv.KeyMetricsDeliverSuccess(timestamp), strconv.FormatInt(instanceID, 10)).Int()
if err != nil {
return 0, c.ProcessError(err)
}
return count, nil
}
func (c *Client) GetMetricsDeliverSuccessTotal(ctx context.Context, timestamp time.Time) (int, kv.Error) {
count, err := c.redis.Get(ctx, kv.KeyMetricsDeliverSuccessTotal(timestamp)).Int()
if err != nil {
return 0, c.ProcessError(err)
}
return count, nil
}
func (c *Client) GetMetricsReceived(ctx context.Context, instanceID int64, timestamp time.Time) (int, kv.Error) {
count, err := c.redis.HGet(ctx, kv.KeyMetricsReceived(timestamp), strconv.FormatInt(instanceID, 10)).Int()
if err != nil {
return 0, c.ProcessError(err)
}
return count, nil
}
func (c *Client) GetMetricsReceivedTotal(ctx context.Context, timestamp time.Time) (int, kv.Error) {
count, err := c.redis.Get(ctx, kv.KeyMetricsReceivedTotal(timestamp)).Int()
if err != nil {
return 0, c.ProcessError(err)
}
return count, nil
}
func (c *Client) IncMetricsDeliverError(ctx context.Context, instanceID int64, timestamp time.Time) kv.Error {
_, err := c.redis.HIncrBy(ctx, kv.KeyMetricsDeliverError(timestamp), strconv.FormatInt(instanceID, 10), 1).Result()
if err != nil {
@ -116,13 +62,108 @@ func (c *Client) IncMetricsReceivedTotal(ctx context.Context, timestamp time.Tim
return nil
}
func (c *Client) MGetAllMetricsDeliverError(ctx context.Context, timestamps []time.Time) (*map[int64]map[time.Time]int, kv.Error) {
func (c *Client) MGetMetricsDeliverError(ctx context.Context, instanceID int64, timestamps []time.Time) (map[time.Time]int, kv.Error) {
return c.mGetMetrics(ctx, instanceID, timestamps, kv.KeyMetricsDeliverError)
}
func (c *Client) MGetAllMetricsDeliverError(ctx context.Context, timestamps []time.Time) (map[int64]map[time.Time]int, kv.Error) {
return c.mGetAllMetrics(ctx, timestamps, kv.KeyMetricsDeliverError)
}
func (c *Client) MGetMetricsDeliverSuccess(ctx context.Context, instanceID int64, timestamps []time.Time) (map[time.Time]int, kv.Error) {
return c.mGetMetrics(ctx, instanceID, timestamps, kv.KeyMetricsDeliverSuccess)
}
func (c *Client) MGetAllMetricsDeliverSuccess(ctx context.Context, timestamps []time.Time) (map[int64]map[time.Time]int, kv.Error) {
return c.mGetAllMetrics(ctx, timestamps, kv.KeyMetricsDeliverSuccess)
}
func (c *Client) MGetMetricsReceived(ctx context.Context, instanceID int64, timestamps []time.Time) (map[time.Time]int, kv.Error) {
return c.mGetMetrics(ctx, instanceID, timestamps, kv.KeyMetricsReceived)
}
func (c *Client) MGetMetricsReceivedTotal(ctx context.Context, timestamps []time.Time) (map[time.Time]int, kv.Error) {
return c.mGetMetricsTotal(ctx, timestamps, kv.KeyMetricsReceivedTotal)
}
func (c *Client) MGetAllMetricsReceived(ctx context.Context, timestamps []time.Time) (map[int64]map[time.Time]int, kv.Error) {
return c.mGetAllMetrics(ctx, timestamps, kv.KeyMetricsReceived)
}
func (c *Client) mGetMetrics(
ctx context.Context,
instanceID int64,
timestamps []time.Time,
genKey func(t time.Time) string,
) (map[time.Time]int, kv.Error) {
pipe := c.redis.Pipeline()
// get results
resultMap := map[time.Time]*redis.StringCmd{}
for _, timestamp := range timestamps {
resultMap[timestamp] = pipe.HGet(ctx, genKey(timestamp), strconv.FormatInt(instanceID, 10))
}
_, err := pipe.Exec(ctx)
if err != nil {
return nil, c.ProcessError(err)
}
// make map
returnMap := map[time.Time]int{}
for t, cmd := range resultMap {
count, err := cmd.Int()
if err != nil {
return nil, err
}
returnMap[t] = count
}
return returnMap, nil
}
func (c *Client) mGetMetricsTotal(
ctx context.Context,
timestamps []time.Time,
genKey func(t time.Time) string,
) (map[time.Time]int, kv.Error) {
pipe := c.redis.Pipeline()
// get results
resultMap := map[time.Time]*redis.StringCmd{}
for _, timestamp := range timestamps {
resultMap[timestamp] = pipe.Get(ctx, genKey(timestamp))
}
_, err := pipe.Exec(ctx)
if err != nil {
return nil, c.ProcessError(err)
}
// make map
returnMap := map[time.Time]int{}
for t, cmd := range resultMap {
count, err := cmd.Int()
if err != nil {
return nil, err
}
returnMap[t] = count
}
return returnMap, nil
}
func (c *Client) mGetAllMetrics(
ctx context.Context,
timestamps []time.Time,
genKey func(t time.Time) string,
) (map[int64]map[time.Time]int, kv.Error) {
pipe := c.redis.Pipeline()
// get results
resultMap := map[time.Time]*redis.StringStringMapCmd{}
for _, timestamp := range timestamps {
resultMap[timestamp] = pipe.HGetAll(ctx, kv.KeyMetricsDeliverError(timestamp))
resultMap[timestamp] = pipe.HGetAll(ctx, genKey(timestamp))
}
_, err := pipe.Exec(ctx)
if err != nil {
@ -162,103 +203,5 @@ func (c *Client) MGetAllMetricsDeliverError(ctx context.Context, timestamps []ti
}
}
return &returnMap, nil
}
func (c *Client) MGetAllMetricsDeliverSuccess(ctx context.Context, timestamps []time.Time) (*map[int64]map[time.Time]int, kv.Error) {
pipe := c.redis.Pipeline()
// get results
resultMap := map[time.Time]*redis.StringStringMapCmd{}
for _, timestamp := range timestamps {
resultMap[timestamp] = pipe.HGetAll(ctx, kv.KeyMetricsDeliverSuccess(timestamp))
}
_, err := pipe.Exec(ctx)
if err != nil {
return nil, c.ProcessError(err)
}
// make map
returnMap := map[int64]map[time.Time]int{}
for t, cmd := range resultMap {
result, err := cmd.Result()
if err != nil {
return nil, err
}
for k, v := range result {
// make ints
instanceID, err := strconv.ParseInt(k, 10, 64)
if err != nil {
return nil, err
}
count, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return nil, err
}
// create map if missing
if _, ok := returnMap[instanceID]; !ok {
returnMap[instanceID] = map[time.Time]int{}
for _, t := range timestamps {
returnMap[instanceID][t] = 0
}
}
// set
returnMap[instanceID][t] = int(count)
}
}
return &returnMap, nil
}
func (c *Client) MGetAllMetricsReceived(ctx context.Context, timestamps []time.Time) (*map[int64]map[time.Time]int, kv.Error) {
pipe := c.redis.Pipeline()
// get results
resultMap := map[time.Time]*redis.StringStringMapCmd{}
for _, timestamp := range timestamps {
resultMap[timestamp] = pipe.HGetAll(ctx, kv.KeyMetricsReceived(timestamp))
}
_, err := pipe.Exec(ctx)
if err != nil {
return nil, c.ProcessError(err)
}
// make map
returnMap := map[int64]map[time.Time]int{}
for t, cmd := range resultMap {
result, err := cmd.Result()
if err != nil {
return nil, err
}
for k, v := range result {
// make ints
instanceID, err := strconv.ParseInt(k, 10, 64)
if err != nil {
return nil, err
}
count, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return nil, err
}
// create map if missing
if _, ok := returnMap[instanceID]; !ok {
returnMap[instanceID] = map[time.Time]int{}
for _, t := range timestamps {
returnMap[instanceID][t] = 0
}
}
// set
returnMap[instanceID][t] = int(count)
}
}
return &returnMap, nil
return returnMap, nil
}

8
internal/logic/logic.go
View File

@ -28,10 +28,10 @@ type Logic interface {
MetricsGetAllDeliverErrorWeek(ctx context.Context) (map[*models.Instance]MetricsDataPointsTime, error)
MetricsGetAllDeliverSuccessWeek(ctx context.Context) (map[*models.Instance]MetricsDataPointsTime, error)
MetricsGetAllReceivedWeek(ctx context.Context) (map[*models.Instance]MetricsDataPointsTime, error)
MetricsGetDeliverErrorWeek(ctx context.Context, instanceID int64) (*MetricsDataPointsTime, error)
MetricsGetDeliverSuccessWeek(ctx context.Context, instanceID int64) (*MetricsDataPointsTime, error)
MetricsGetReceivedWeek(ctx context.Context, instanceID int64) (*MetricsDataPointsTime, error)
MetricsGetReceivedTotalWeek(ctx context.Context) (*MetricsDataPointsTime, error)
MetricsGetDeliverErrorWeek(ctx context.Context, instanceID int64) (MetricsDataPointsTime, error)
MetricsGetDeliverSuccessWeek(ctx context.Context, instanceID int64) (MetricsDataPointsTime, error)
MetricsGetReceivedWeek(ctx context.Context, instanceID int64) (MetricsDataPointsTime, error)
MetricsGetReceivedTotalWeek(ctx context.Context) (MetricsDataPointsTime, error)
MetricsIncDeliverError(ctx context.Context, instanceID int64)
MetricsIncDeliverSuccess(ctx context.Context, instanceID int64)
MetricsIncReceived(ctx context.Context, instanceID int64)

264
internal/logic/logic1/metrics_get.go
View File

@ -2,195 +2,113 @@ package logic1
import (
"context"
"errors"
"github.com/feditools/relay/internal/kv"
"github.com/feditools/relay/internal/logic"
"github.com/feditools/relay/internal/models"
"time"
)
func (l *Logic) MetricsGetDeliverErrorWeek(ctx context.Context, instanceID int64) (*logic.MetricsDataPointsTime, error) {
now := time.Now().UTC()
now = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
var days logic.MetricsDataPointsTime = make([]logic.MetricsDataPointTime, 7)
for i := 0; i < 7; i++ {
day := now.Add(-24 * time.Duration(i) * time.Hour)
count := 0
var err error
count, err = l.kv.GetMetricsDeliverError(ctx, instanceID, day)
if err != nil && !errors.Is(err, kv.ErrNil) {
return nil, err
}
days[i] = logic.MetricsDataPointTime{
X: day,
Y: count,
}
}
return &days, nil
func (l *Logic) MetricsGetDeliverErrorWeek(ctx context.Context, instanceID int64) (logic.MetricsDataPointsTime, error) {
return l.metricsGetWeek(ctx, instanceID, l.kv.MGetMetricsDeliverError)
}
func (l *Logic) MetricsGetAllDeliverErrorWeek(ctx context.Context) (map[*models.Instance]logic.MetricsDataPointsTime, error) {
now := time.Now().UTC()
now = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
// build set of days
days := make([]time.Time, 7)
days[0] = now
for i := time.Duration(1); i < 7; i++ {
days[i] = now.Add(-24 * i * time.Hour)
}
// get data points from kv
dps, err := l.kv.MGetAllMetricsDeliverError(ctx, days)
if err != nil {
return nil, err
}
// lookup instances
var instanceIDs []int64
for i, _ := range *dps {
instanceIDs = append(instanceIDs, i)
}
instances, err := l.db.ReadInstances(ctx, instanceIDs...)
if err != nil {
return nil, err
}
// make map
returnMap := map[*models.Instance]logic.MetricsDataPointsTime{}
for _, instance := range instances {
var dataPoints logic.MetricsDataPointsTime
for _, day := range days {
dataPoints = append(dataPoints, logic.MetricsDataPointTime{
X: day,
Y: (*dps)[instance.ID][day],
})
}
returnMap[instance] = dataPoints
}
return returnMap, nil
return l.metricsGetAllWeek(ctx, l.kv.MGetAllMetricsDeliverError)
}
func (l *Logic) MetricsGetDeliverSuccessWeek(ctx context.Context, instanceID int64) (*logic.MetricsDataPointsTime, error) {
now := time.Now().UTC()
now = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
var days logic.MetricsDataPointsTime = make([]logic.MetricsDataPointTime, 7)
for i := 0; i < 7; i++ {
day := now.Add(-24 * time.Duration(i) * time.Hour)
count := 0
var err error
count, err = l.kv.GetMetricsDeliverSuccess(ctx, instanceID, day)
if err != nil && !errors.Is(err, kv.ErrNil) {
return nil, err
}
days[i] = logic.MetricsDataPointTime{
X: day,
Y: count,
}
}
return &days, nil
func (l *Logic) MetricsGetDeliverSuccessWeek(ctx context.Context, instanceID int64) (logic.MetricsDataPointsTime, error) {
return l.metricsGetWeek(ctx, instanceID, l.kv.MGetMetricsDeliverSuccess)
}
func (l *Logic) MetricsGetAllDeliverSuccessWeek(ctx context.Context) (map[*models.Instance]logic.MetricsDataPointsTime, error) {
now := time.Now().UTC()
now = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
// build set of days
days := make([]time.Time, 7)
days[0] = now
for i := time.Duration(1); i < 7; i++ {
days[i] = now.Add(-24 * i * time.Hour)
}
// get data points from kv
dps, err := l.kv.MGetAllMetricsDeliverSuccess(ctx, days)
if err != nil {
return nil, err
}
// lookup instances
var instanceIDs []int64
for i, _ := range *dps {
instanceIDs = append(instanceIDs, i)
}
instances, err := l.db.ReadInstances(ctx, instanceIDs...)
if err != nil {
return nil, err
}
// make map
returnMap := map[*models.Instance]logic.MetricsDataPointsTime{}
for _, instance := range instances {
var dataPoints logic.MetricsDataPointsTime
for _, day := range days {
dataPoints = append(dataPoints, logic.MetricsDataPointTime{
X: day,
Y: (*dps)[instance.ID][day],
})
}
returnMap[instance] = dataPoints
}
return returnMap, nil
return l.metricsGetAllWeek(ctx, l.kv.MGetAllMetricsDeliverSuccess)
}
func (l *Logic) MetricsGetReceivedWeek(ctx context.Context, instanceID int64) (*logic.MetricsDataPointsTime, error) {
now := time.Now().UTC()
now = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
var days logic.MetricsDataPointsTime = make([]logic.MetricsDataPointTime, 7)
for i := 0; i < 7; i++ {
day := now.Add(-24 * time.Duration(i) * time.Hour)
count := 0
var err error
count, err = l.kv.GetMetricsReceived(ctx, instanceID, day)
if err != nil && !errors.Is(err, kv.ErrNil) {
return nil, err
}
days[i] = logic.MetricsDataPointTime{
X: day,
Y: count,
}
}
return &days, nil
func (l *Logic) MetricsGetReceivedWeek(ctx context.Context, instanceID int64) (logic.MetricsDataPointsTime, error) {
return l.metricsGetWeek(ctx, instanceID, l.kv.MGetMetricsReceived)
}
func (l *Logic) MetricsGetAllReceivedWeek(ctx context.Context) (map[*models.Instance]logic.MetricsDataPointsTime, error) {
now := time.Now().UTC()
now = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
return l.metricsGetAllWeek(ctx, l.kv.MGetAllMetricsReceived)
}
func (l *Logic) MetricsGetReceivedTotalWeek(ctx context.Context) (logic.MetricsDataPointsTime, error) {
return l.metricsGetTotalWeek(ctx, l.kv.MGetMetricsReceivedTotal)
}
func (l *Logic) metricsGetWeek(
ctx context.Context,
instanceID int64,
getFunc func(ctx context.Context, instanceID int64, timestamps []time.Time) (map[time.Time]int, kv.Error),
) (logic.MetricsDataPointsTime, error) {
// build set of days
days := make([]time.Time, 7)
days[0] = now
for i := time.Duration(1); i < 7; i++ {
days[i] = now.Add(-24 * i * time.Hour)
}
days := makeDaysBefore(time.Now().UTC(), 7)
// get data points from kv
dps, err := l.kv.MGetAllMetricsReceived(ctx, days)
dps, err := getFunc(ctx, instanceID, days)
if err != nil {
return nil, err
}
var dataPoints logic.MetricsDataPointsTime = make([]logic.MetricsDataPointTime, len(days))
for i, day := range days {
dataPoints[i] = logic.MetricsDataPointTime{
X: day,
Y: dps[day],
}
}
return dataPoints, nil
}
func (l *Logic) metricsGetTotalWeek(
ctx context.Context,
getFunc func(ctx context.Context, timestamps []time.Time) (map[time.Time]int, kv.Error),
) (logic.MetricsDataPointsTime, error) {
// build set of dataPoints
days := makeDaysBefore(time.Now().UTC(), 7)
// get data points from kv
dps, err := getFunc(ctx, days)
if err != nil {
return nil, err
}
var dataPoints logic.MetricsDataPointsTime = make([]logic.MetricsDataPointTime, 7)
for i, day := range days {
dataPoints[i] = logic.MetricsDataPointTime{
X: day,
Y: dps[day],
}
}
return dataPoints, nil
}
func (l *Logic) metricsGetAllWeek(
ctx context.Context,
getFunc func(ctx context.Context, timestamps []time.Time) (map[int64]map[time.Time]int, kv.Error),
) (map[*models.Instance]logic.MetricsDataPointsTime, error) {
// build set of days
days := makeDaysBefore(time.Now().UTC(), 7)
// get data points from kv
dps, err := getFunc(ctx, days)
if err != nil {
return nil, err
}
// lookup instances
var instanceIDs []int64
for i, _ := range *dps {
for i, _ := range dps {
instanceIDs = append(instanceIDs, i)
}
// return empty if no instances found
if len(instanceIDs) == 0 {
return map[*models.Instance]logic.MetricsDataPointsTime{}, nil
}
instances, err := l.db.ReadInstances(ctx, instanceIDs...)
if err != nil {
return nil, err
@ -203,7 +121,7 @@ func (l *Logic) MetricsGetAllReceivedWeek(ctx context.Context) (map[*models.Inst
for _, day := range days {
dataPoints = append(dataPoints, logic.MetricsDataPointTime{
X: day,
Y: (*dps)[instance.ID][day],
Y: dps[instance.ID][day],
})
}
@ -213,26 +131,16 @@ func (l *Logic) MetricsGetAllReceivedWeek(ctx context.Context) (map[*models.Inst
return returnMap, nil
}
func (l *Logic) MetricsGetReceivedTotalWeek(ctx context.Context) (*logic.MetricsDataPointsTime, error) {
now := time.Now().UTC()
now = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
func makeDaysBefore(lastDay time.Time, count int) []time.Time {
lastDayTruncated := time.Date(lastDay.Year(), lastDay.Month(), lastDay.Day(), 0, 0, 0, 0, lastDay.Location())
var days logic.MetricsDataPointsTime = make([]logic.MetricsDataPointTime, 7)
for i := 0; i < 7; i++ {
day := now.Add(-24 * time.Duration(i) * time.Hour)
count := 0
var err error
count, err = l.kv.GetMetricsReceivedTotal(ctx, day)
if err != nil && !errors.Is(err, kv.ErrNil) {
return nil, err
}
days[i] = logic.MetricsDataPointTime{
X: day,
Y: count,
}
// build set of days
days := make([]time.Time, count)
days[0] = lastDayTruncated
for i := 1; i < count; i++ {
offset := -24 * time.Duration(i) * time.Hour
days[i] = lastDayTruncated.Add(offset)
}
return &days, nil
return days
}