mirror of
https://github.com/grafana/grafana.git
synced 2024-11-26 19:00:54 -06:00
665 lines
20 KiB
Go
665 lines
20 KiB
Go
package annotationsimpl
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/grafana/grafana/pkg/components/simplejson"
|
|
"github.com/grafana/grafana/pkg/infra/db"
|
|
"github.com/grafana/grafana/pkg/infra/log"
|
|
"github.com/grafana/grafana/pkg/services/accesscontrol"
|
|
"github.com/grafana/grafana/pkg/services/annotations"
|
|
annotation_ac "github.com/grafana/grafana/pkg/services/annotations/accesscontrol"
|
|
"github.com/grafana/grafana/pkg/services/annotations/testutil"
|
|
"github.com/grafana/grafana/pkg/services/dashboards"
|
|
"github.com/grafana/grafana/pkg/services/featuremgmt"
|
|
"github.com/grafana/grafana/pkg/services/sqlstore"
|
|
"github.com/grafana/grafana/pkg/services/tag"
|
|
"github.com/grafana/grafana/pkg/services/tag/tagimpl"
|
|
"github.com/grafana/grafana/pkg/services/user"
|
|
"github.com/grafana/grafana/pkg/setting"
|
|
)
|
|
|
|
func TestIntegrationAnnotations(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("skipping integration test")
|
|
}
|
|
sql := db.InitTestDB(t)
|
|
|
|
cfg := setting.NewCfg()
|
|
cfg.AnnotationMaximumTagsLength = 60
|
|
|
|
store := NewXormStore(cfg, log.New("annotation.test"), sql, tagimpl.ProvideService(sql))
|
|
|
|
testUser := &user.SignedInUser{
|
|
OrgID: 1,
|
|
Permissions: map[int64]map[string][]string{
|
|
1: {
|
|
accesscontrol.ActionAnnotationsRead: []string{accesscontrol.ScopeAnnotationsAll},
|
|
dashboards.ActionDashboardsRead: []string{dashboards.ScopeDashboardsAll},
|
|
},
|
|
},
|
|
}
|
|
|
|
t.Run("Testing annotation create, read, update and delete", func(t *testing.T) {
|
|
t.Cleanup(func() {
|
|
err := sql.WithDbSession(context.Background(), func(dbSession *db.Session) error {
|
|
_, err := dbSession.Exec("DELETE FROM annotation WHERE 1=1")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = dbSession.Exec("DELETE FROM annotation_tag WHERE 1=1")
|
|
return err
|
|
})
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
dashboard := testutil.CreateDashboard(t, sql, featuremgmt.WithFeatures(), dashboards.SaveDashboardCommand{
|
|
UserID: 1,
|
|
OrgID: 1,
|
|
Dashboard: simplejson.NewFromAny(map[string]any{
|
|
"title": "Dashboard 1",
|
|
}),
|
|
})
|
|
|
|
dashboard2 := testutil.CreateDashboard(t, sql, featuremgmt.WithFeatures(), dashboards.SaveDashboardCommand{
|
|
UserID: 1,
|
|
OrgID: 1,
|
|
Dashboard: simplejson.NewFromAny(map[string]any{
|
|
"title": "Dashboard 2",
|
|
}),
|
|
})
|
|
|
|
var err error
|
|
|
|
annotation := &annotations.Item{
|
|
OrgID: 1,
|
|
UserID: 1,
|
|
DashboardID: dashboard.ID,
|
|
Text: "hello",
|
|
Type: "alert",
|
|
Epoch: 10,
|
|
Tags: []string{"outage", "error", "type:outage", "server:server-1"},
|
|
Data: simplejson.NewFromAny(map[string]any{"data1": "I am a cool data", "data2": "I am another cool data"}),
|
|
}
|
|
err = store.Add(context.Background(), annotation)
|
|
require.NoError(t, err)
|
|
assert.Greater(t, annotation.ID, int64(0))
|
|
assert.Equal(t, annotation.Epoch, annotation.EpochEnd)
|
|
|
|
annotation2 := &annotations.Item{
|
|
OrgID: 1,
|
|
UserID: 1,
|
|
DashboardID: dashboard2.ID,
|
|
Text: "hello",
|
|
Type: "alert",
|
|
Epoch: 21, // Should swap epoch & epochEnd
|
|
EpochEnd: 20,
|
|
Tags: []string{"outage", "type:outage", "server:server-1", "error"},
|
|
}
|
|
err = store.Add(context.Background(), annotation2)
|
|
require.NoError(t, err)
|
|
assert.Greater(t, annotation2.ID, int64(0))
|
|
assert.Equal(t, int64(20), annotation2.Epoch)
|
|
assert.Equal(t, int64(21), annotation2.EpochEnd)
|
|
|
|
organizationAnnotation1 := &annotations.Item{
|
|
OrgID: 1,
|
|
UserID: 1,
|
|
Text: "deploy",
|
|
Type: "",
|
|
Epoch: 15,
|
|
Tags: []string{"deploy"},
|
|
}
|
|
err = store.Add(context.Background(), organizationAnnotation1)
|
|
require.NoError(t, err)
|
|
assert.Greater(t, organizationAnnotation1.ID, int64(0))
|
|
|
|
organizationAnnotation2 := &annotations.Item{
|
|
OrgID: 1,
|
|
UserID: 1,
|
|
Text: "rollback",
|
|
Type: "",
|
|
Epoch: 17,
|
|
Tags: []string{"rollback"},
|
|
}
|
|
err = store.Add(context.Background(), organizationAnnotation2)
|
|
require.NoError(t, err)
|
|
assert.Greater(t, organizationAnnotation2.ID, int64(0))
|
|
|
|
t.Run("Can query for annotation by dashboard id", func(t *testing.T) {
|
|
items, err := store.Get(context.Background(), &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: dashboard.ID,
|
|
From: 0,
|
|
To: 15,
|
|
SignedInUser: testUser,
|
|
}, &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{
|
|
dashboard.UID: dashboard.ID,
|
|
},
|
|
CanAccessDashAnnotations: true,
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
assert.Len(t, items, 1)
|
|
|
|
assert.Equal(t, []string{"outage", "error", "type:outage", "server:server-1"}, items[0].Tags)
|
|
|
|
assert.GreaterOrEqual(t, items[0].Created, int64(0))
|
|
assert.GreaterOrEqual(t, items[0].Updated, int64(0))
|
|
assert.Equal(t, items[0].Updated, items[0].Created)
|
|
})
|
|
|
|
badAnnotation := &annotations.Item{
|
|
OrgID: 1,
|
|
UserID: 1,
|
|
Text: "rollback",
|
|
Type: "",
|
|
Epoch: 17,
|
|
Tags: []string{strings.Repeat("a", int(cfg.AnnotationMaximumTagsLength+1))},
|
|
}
|
|
err = store.Add(context.Background(), badAnnotation)
|
|
require.Error(t, err)
|
|
require.ErrorIs(t, err, annotations.ErrBaseTagLimitExceeded)
|
|
|
|
t.Run("Can batch-insert annotations", func(t *testing.T) {
|
|
count := 10
|
|
items := make([]annotations.Item, count)
|
|
for i := 0; i < count; i++ {
|
|
items[i] = annotations.Item{
|
|
OrgID: 100,
|
|
Type: "batch",
|
|
Epoch: 12,
|
|
}
|
|
}
|
|
|
|
err := store.AddMany(context.Background(), items)
|
|
|
|
require.NoError(t, err)
|
|
query := &annotations.ItemQuery{OrgID: 100, SignedInUser: testUser}
|
|
accRes := &annotation_ac.AccessResources{CanAccessOrgAnnotations: true}
|
|
inserted, err := store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
assert.Len(t, inserted, count)
|
|
for _, ins := range inserted {
|
|
require.Equal(t, int64(12), ins.Time)
|
|
require.Equal(t, int64(12), ins.TimeEnd)
|
|
require.Equal(t, ins.Created, ins.Updated)
|
|
}
|
|
})
|
|
|
|
t.Run("Can batch-insert annotations with tags", func(t *testing.T) {
|
|
count := 10
|
|
items := make([]annotations.Item, count)
|
|
for i := 0; i < count; i++ {
|
|
items[i] = annotations.Item{
|
|
OrgID: 101,
|
|
Type: "batch",
|
|
Epoch: 12,
|
|
}
|
|
}
|
|
items[0].Tags = []string{"type:test"}
|
|
|
|
err := store.AddMany(context.Background(), items)
|
|
|
|
require.NoError(t, err)
|
|
query := &annotations.ItemQuery{OrgID: 101, SignedInUser: testUser}
|
|
accRes := &annotation_ac.AccessResources{CanAccessOrgAnnotations: true}
|
|
inserted, err := store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
assert.Len(t, inserted, count)
|
|
})
|
|
|
|
t.Run("Can query for annotation by id", func(t *testing.T) {
|
|
items, err := store.Get(context.Background(), &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
AnnotationID: annotation2.ID,
|
|
SignedInUser: testUser,
|
|
}, &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{
|
|
dashboard2.UID: dashboard2.ID,
|
|
},
|
|
CanAccessDashAnnotations: true,
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Len(t, items, 1)
|
|
assert.Equal(t, annotation2.ID, items[0].ID)
|
|
})
|
|
|
|
t.Run("Should not find any when item is outside time range", func(t *testing.T) {
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 12,
|
|
To: 15,
|
|
SignedInUser: testUser,
|
|
}, accRes)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, items)
|
|
})
|
|
|
|
t.Run("Should not find one when tag filter does not match", func(t *testing.T) {
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 1,
|
|
To: 15,
|
|
Tags: []string{"asd"},
|
|
SignedInUser: testUser,
|
|
}, accRes)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, items)
|
|
})
|
|
|
|
t.Run("Should not find one when type filter does not match", func(t *testing.T) {
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 1,
|
|
To: 15,
|
|
Type: "alert",
|
|
SignedInUser: testUser,
|
|
}, accRes)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, items)
|
|
})
|
|
|
|
t.Run("Should find one when all tag filters does match", func(t *testing.T) {
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 1,
|
|
To: 15, // this will exclude the second test annotation
|
|
Tags: []string{"outage", "error"},
|
|
SignedInUser: testUser,
|
|
}, accRes)
|
|
require.NoError(t, err)
|
|
assert.Len(t, items, 1)
|
|
})
|
|
|
|
t.Run("Should find two annotations using partial match", func(t *testing.T) {
|
|
accRes := &annotation_ac.AccessResources{CanAccessOrgAnnotations: true}
|
|
items, err := store.Get(context.Background(), &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
From: 1,
|
|
To: 25,
|
|
MatchAny: true,
|
|
Tags: []string{"rollback", "deploy"},
|
|
SignedInUser: testUser,
|
|
}, accRes)
|
|
require.NoError(t, err)
|
|
assert.Len(t, items, 2)
|
|
})
|
|
|
|
t.Run("Should find one when all key value tag filters does match", func(t *testing.T) {
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 1,
|
|
To: 15,
|
|
Tags: []string{"type:outage", "server:server-1"},
|
|
SignedInUser: testUser,
|
|
}, accRes)
|
|
require.NoError(t, err)
|
|
assert.Len(t, items, 1)
|
|
})
|
|
|
|
t.Run("Can update annotation and remove all tags", func(t *testing.T) {
|
|
query := &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 0,
|
|
To: 15,
|
|
SignedInUser: testUser,
|
|
}
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
annotationId := items[0].ID
|
|
err = store.Update(context.Background(), &annotations.Item{
|
|
ID: annotationId,
|
|
OrgID: 1,
|
|
Text: "something new",
|
|
Tags: []string{},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
items, err = store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, annotationId, items[0].ID)
|
|
assert.Empty(t, items[0].Tags)
|
|
assert.Equal(t, "something new", items[0].Text)
|
|
data, err := items[0].Data.Map()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, data, map[string]any{"data1": "I am a cool data", "data2": "I am another cool data"})
|
|
})
|
|
|
|
t.Run("Can update annotation with new tags", func(t *testing.T) {
|
|
query := &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 0,
|
|
To: 15,
|
|
SignedInUser: testUser,
|
|
}
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
annotationId := items[0].ID
|
|
err = store.Update(context.Background(), &annotations.Item{
|
|
ID: annotationId,
|
|
OrgID: 1,
|
|
Text: "something new",
|
|
Tags: []string{"newtag1", "newtag2"},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
items, err = store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, annotationId, items[0].ID)
|
|
assert.Equal(t, []string{"newtag1", "newtag2"}, items[0].Tags)
|
|
assert.Equal(t, "something new", items[0].Text)
|
|
assert.Greater(t, items[0].Updated, items[0].Created)
|
|
})
|
|
|
|
t.Run("Can update annotation with additional tags", func(t *testing.T) {
|
|
query := &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 0,
|
|
To: 15,
|
|
SignedInUser: testUser,
|
|
}
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
annotationId := items[0].ID
|
|
err = store.Update(context.Background(), &annotations.Item{
|
|
ID: annotationId,
|
|
OrgID: 1,
|
|
Text: "something new",
|
|
Tags: []string{"newtag1", "newtag3"},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
items, err = store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, annotationId, items[0].ID)
|
|
assert.Equal(t, []string{"newtag1", "newtag3"}, items[0].Tags)
|
|
assert.Equal(t, "something new", items[0].Text)
|
|
assert.Greater(t, items[0].Updated, items[0].Created)
|
|
})
|
|
|
|
t.Run("Can update annotations with data", func(t *testing.T) {
|
|
query := &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 0,
|
|
To: 15,
|
|
SignedInUser: testUser,
|
|
}
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
annotationId := items[0].ID
|
|
data := simplejson.NewFromAny(map[string]any{"data": "I am a data", "data2": "I am also a data"})
|
|
err = store.Update(context.Background(), &annotations.Item{
|
|
ID: annotationId,
|
|
OrgID: 1,
|
|
Text: "something new",
|
|
Tags: []string{"newtag1", "newtag2"},
|
|
Data: data,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
items, err = store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, annotationId, items[0].ID)
|
|
assert.Equal(t, []string{"newtag1", "newtag2"}, items[0].Tags)
|
|
assert.Equal(t, "something new", items[0].Text)
|
|
assert.Greater(t, items[0].Updated, items[0].Created)
|
|
assert.Equal(t, data, items[0].Data)
|
|
})
|
|
|
|
t.Run("Can delete annotation", func(t *testing.T) {
|
|
query := &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
DashboardID: 1,
|
|
From: 0,
|
|
To: 15,
|
|
SignedInUser: testUser,
|
|
}
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{"foo": 1},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
items, err := store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
annotationId := items[0].ID
|
|
err = store.Delete(context.Background(), &annotations.DeleteParams{ID: annotationId, OrgID: 1})
|
|
require.NoError(t, err)
|
|
|
|
items, err = store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, items)
|
|
})
|
|
|
|
t.Run("Can delete annotation using dashboard id and panel id", func(t *testing.T) {
|
|
annotation3 := &annotations.Item{
|
|
OrgID: 1,
|
|
UserID: 1,
|
|
DashboardID: dashboard2.ID,
|
|
Text: "toBeDeletedWithPanelId",
|
|
Type: "alert",
|
|
Epoch: 11,
|
|
Tags: []string{"test"},
|
|
PanelID: 20,
|
|
}
|
|
err = store.Add(context.Background(), annotation3)
|
|
require.NoError(t, err)
|
|
|
|
accRes := &annotation_ac.AccessResources{
|
|
Dashboards: map[string]int64{
|
|
dashboard2.UID: dashboard2.ID,
|
|
},
|
|
CanAccessDashAnnotations: true,
|
|
}
|
|
|
|
query := &annotations.ItemQuery{
|
|
OrgID: 1,
|
|
AnnotationID: annotation3.ID,
|
|
SignedInUser: testUser,
|
|
}
|
|
items, err := store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
|
|
dashboardId := items[0].DashboardID
|
|
panelId := items[0].PanelID
|
|
err = store.Delete(context.Background(), &annotations.DeleteParams{DashboardID: dashboardId, PanelID: panelId, OrgID: 1})
|
|
require.NoError(t, err)
|
|
|
|
items, err = store.Get(context.Background(), query, accRes)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, items)
|
|
})
|
|
|
|
t.Run("Should find tags by key", func(t *testing.T) {
|
|
result, err := store.GetTags(context.Background(), &annotations.TagsQuery{
|
|
OrgID: 1,
|
|
Tag: "server",
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, result.Tags, 1)
|
|
require.Equal(t, "server:server-1", result.Tags[0].Tag)
|
|
require.Equal(t, int64(1), result.Tags[0].Count)
|
|
})
|
|
|
|
t.Run("Should find tags by value", func(t *testing.T) {
|
|
result, err := store.GetTags(context.Background(), &annotations.TagsQuery{
|
|
OrgID: 1,
|
|
Tag: "outage",
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, result.Tags, 2)
|
|
require.Equal(t, "outage", result.Tags[0].Tag)
|
|
require.Equal(t, "type:outage", result.Tags[1].Tag)
|
|
require.Equal(t, int64(1), result.Tags[0].Count)
|
|
require.Equal(t, int64(1), result.Tags[1].Count)
|
|
})
|
|
|
|
t.Run("Should not find tags in other org", func(t *testing.T) {
|
|
result, err := store.GetTags(context.Background(), &annotations.TagsQuery{
|
|
OrgID: 0,
|
|
Tag: "server-1",
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, result.Tags, 0)
|
|
})
|
|
|
|
t.Run("Should not find tags that do not exist", func(t *testing.T) {
|
|
result, err := store.GetTags(context.Background(), &annotations.TagsQuery{
|
|
OrgID: 0,
|
|
Tag: "unknown:tag",
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, result.Tags, 0)
|
|
})
|
|
})
|
|
}
|
|
|
|
func BenchmarkFindTags_10k(b *testing.B) {
|
|
benchmarkFindTags(b, 10000)
|
|
}
|
|
|
|
func BenchmarkFindTags_100k(b *testing.B) {
|
|
benchmarkFindTags(b, 100000)
|
|
}
|
|
|
|
func benchmarkFindTags(b *testing.B, numAnnotations int) {
|
|
sql := db.InitTestDB(b)
|
|
cfg := setting.NewCfg()
|
|
cfg.AnnotationMaximumTagsLength = 60
|
|
store := xormRepositoryImpl{db: sql, cfg: cfg, log: log.New("annotation.test"), tagService: tagimpl.ProvideService(sql)}
|
|
|
|
type annotationTag struct {
|
|
ID int64 `xorm:"pk autoincr 'id'"`
|
|
AnnotationID int64 `xorm:"annotation_id"`
|
|
TagID int64 `xorm:"tag_id"`
|
|
}
|
|
newAnnotations := make([]annotations.Item, 0, numAnnotations)
|
|
newTags := make([]tag.Tag, 0, numAnnotations)
|
|
newAnnotationTags := make([]annotationTag, 0, numAnnotations)
|
|
for i := 0; i < numAnnotations; i++ {
|
|
newAnnotations = append(newAnnotations, annotations.Item{
|
|
ID: int64(i),
|
|
OrgID: 1,
|
|
UserID: 1,
|
|
DashboardID: int64(i),
|
|
Text: "hello",
|
|
Type: "alert",
|
|
Epoch: 10,
|
|
Data: simplejson.NewFromAny(map[string]any{"data1": "I am a cool data", "data2": "I am another cool data"}),
|
|
})
|
|
newTags = append(newTags, tag.Tag{
|
|
Id: int64(i),
|
|
Key: fmt.Sprintf("tag%d", i),
|
|
})
|
|
|
|
newAnnotationTags = append(newAnnotationTags, annotationTag{
|
|
AnnotationID: int64(i),
|
|
TagID: int64(1),
|
|
})
|
|
}
|
|
err := sql.WithDbSession(context.Background(), func(sess *sqlstore.DBSession) error {
|
|
batchSize := 1000
|
|
numOfBatches := numAnnotations / batchSize
|
|
for i := 0; i < numOfBatches; i++ {
|
|
_, err := sess.Insert(newAnnotations[i*batchSize : (i+1)*batchSize-1])
|
|
require.NoError(b, err)
|
|
|
|
_, err = sess.Insert(newTags[i*batchSize : (i+1)*batchSize-1])
|
|
require.NoError(b, err)
|
|
|
|
_, err = sess.Insert(newAnnotationTags[i*batchSize : (i+1)*batchSize-1])
|
|
require.NoError(b, err)
|
|
}
|
|
return nil
|
|
})
|
|
require.NoError(b, err)
|
|
|
|
annotationWithTheTag := annotations.Item{
|
|
ID: int64(numAnnotations) + 1,
|
|
OrgID: 1,
|
|
UserID: 1,
|
|
DashboardID: int64(1),
|
|
Text: "hello",
|
|
Type: "alert",
|
|
Epoch: 10,
|
|
Tags: []string{"outage", "error", "type:outage", "server:server-1"},
|
|
Data: simplejson.NewFromAny(map[string]any{"data1": "I am a cool data", "data2": "I am another cool data"}),
|
|
}
|
|
err = store.Add(context.Background(), &annotationWithTheTag)
|
|
require.NoError(b, err)
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
result, err := store.GetTags(context.Background(), &annotations.TagsQuery{
|
|
OrgID: 1,
|
|
Tag: "outage",
|
|
})
|
|
require.NoError(b, err)
|
|
require.Len(b, result.Tags, 2)
|
|
require.Equal(b, "outage", result.Tags[0].Tag)
|
|
require.Equal(b, "type:outage", result.Tags[1].Tag)
|
|
require.Equal(b, int64(1), result.Tags[0].Count)
|
|
require.Equal(b, int64(1), result.Tags[1].Count)
|
|
}
|
|
}
|