prometheus

1
// Copyright 2019 The Prometheus Authors
2
// Licensed under the Apache License, Version 2.0 (the "License");
3
// you may not use this file except in compliance with the License.
4
// You may obtain a copy of the License at
5
//
6
// http://www.apache.org/licenses/LICENSE-2.0
7
//
8
// Unless required by applicable law or agreed to in writing, software
9
// distributed under the License is distributed on an "AS IS" BASIS,
10
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11
// See the License for the specific language governing permissions and
12
// limitations under the License.
13

14
package promql
15

16
import (
17
	"context"
18
	"os"
19
	"testing"
20

21
	"github.com/grafana/regexp"
22
	"github.com/stretchr/testify/require"
23
)
24

25
func TestQueryLogging(t *testing.T) {
26
	fileAsBytes := make([]byte, 4096)
27
	queryLogger := ActiveQueryTracker{
28
		mmapedFile:   fileAsBytes,
29
		logger:       nil,
30
		getNextIndex: make(chan int, 4),
31
	}
32

33
	queryLogger.generateIndices(4)
34
	veryLongString := "MassiveQueryThatNeverEndsAndExceedsTwoHundredBytesWhichIsTheSizeOfEntrySizeAndShouldThusBeTruncatedAndIamJustGoingToRepeatTheSameCharactersAgainProbablyBecauseWeAreStillOnlyHalfWayDoneOrMaybeNotOrMaybeMassiveQueryThatNeverEndsAndExceedsTwoHundredBytesWhichIsTheSizeOfEntrySizeAndShouldThusBeTruncatedAndIamJustGoingToRepeatTheSameCharactersAgainProbablyBecauseWeAreStillOnlyHalfWayDoneOrMaybeNotOrMaybeMassiveQueryThatNeverEndsAndExceedsTwoHundredBytesWhichIsTheSizeOfEntrySizeAndShouldThusBeTruncatedAndIamJustGoingToRepeatTheSameCharactersAgainProbablyBecauseWeAreStillOnlyHalfWayDoneOrMaybeNotOrMaybeMassiveQueryThatNeverEndsAndExceedsTwoHundredBytesWhichIsTheSizeOfEntrySizeAndShouldThusBeTruncatedAndIamJustGoingToRepeatTheSameCharactersAgainProbablyBecauseWeAreStillOnlyHalfWayDoneOrMaybeNotOrMaybeMassiveQueryThatNeverEndsAndExceedsTwoHundredBytesWhichIsTheSizeOfEntrySizeAndShouldThusBeTruncatedAndIamJustGoingToRepeatTheSameCharactersAgainProbablyBecauseWeAreStillOnlyHalfWayDoneOrMaybeNotOrMaybe"
35
	queries := []string{
36
		"TestQuery",
37
		veryLongString,
38
		"",
39
		"SpecialCharQuery{host=\"2132132\", id=123123}",
40
	}
41

42
	want := []string{
43
		`^{"query":"TestQuery","timestamp_sec":\d+}\x00*,$`,
44
		`^{"query":"` + trimStringByBytes(veryLongString, entrySize-40) + `","timestamp_sec":\d+}\x00*,$`,
45
		`^{"query":"","timestamp_sec":\d+}\x00*,$`,
46
		`^{"query":"SpecialCharQuery{host=\\"2132132\\", id=123123}","timestamp_sec":\d+}\x00*,$`,
47
	}
48

49
	// Check for inserts of queries.
50
	for i := 0; i < 4; i++ {
51
		start := 1 + i*entrySize
52
		end := start + entrySize
53

54
		queryLogger.Insert(context.Background(), queries[i])
55

56
		have := string(fileAsBytes[start:end])
57
		require.True(t, regexp.MustCompile(want[i]).MatchString(have),
58
			"Query not written correctly: %s", queries[i])
59
	}
60

61
	// Check if all queries have been deleted.
62
	for i := 0; i < 4; i++ {
63
		queryLogger.Delete(1 + i*entrySize)
64
	}
65
	require.True(t, regexp.MustCompile(`^\x00+$`).Match(fileAsBytes[1:1+entrySize*4]),
66
		"All queries not deleted properly. Want only null bytes \\x00")
67
}
68

69
func TestIndexReuse(t *testing.T) {
70
	queryBytes := make([]byte, 1+3*entrySize)
71
	queryLogger := ActiveQueryTracker{
72
		mmapedFile:   queryBytes,
73
		logger:       nil,
74
		getNextIndex: make(chan int, 3),
75
	}
76

77
	queryLogger.generateIndices(3)
78
	queryLogger.Insert(context.Background(), "TestQuery1")
79
	queryLogger.Insert(context.Background(), "TestQuery2")
80
	queryLogger.Insert(context.Background(), "TestQuery3")
81

82
	queryLogger.Delete(1 + entrySize)
83
	queryLogger.Delete(1)
84
	newQuery2 := "ThisShouldBeInsertedAtIndex2"
85
	newQuery1 := "ThisShouldBeInsertedAtIndex1"
86
	queryLogger.Insert(context.Background(), newQuery2)
87
	queryLogger.Insert(context.Background(), newQuery1)
88

89
	want := []string{
90
		`^{"query":"ThisShouldBeInsertedAtIndex1","timestamp_sec":\d+}\x00*,$`,
91
		`^{"query":"ThisShouldBeInsertedAtIndex2","timestamp_sec":\d+}\x00*,$`,
92
		`^{"query":"TestQuery3","timestamp_sec":\d+}\x00*,$`,
93
	}
94

95
	// Check all bytes and verify new query was inserted at index 2
96
	for i := 0; i < 3; i++ {
97
		start := 1 + i*entrySize
98
		end := start + entrySize
99

100
		have := queryBytes[start:end]
101
		require.True(t, regexp.MustCompile(want[i]).Match(have),
102
			"Index not reused properly.")
103
	}
104
}
105

106
func TestMMapFile(t *testing.T) {
107
	file, err := os.CreateTemp("", "mmapedFile")
108
	require.NoError(t, err)
109

110
	filename := file.Name()
111
	defer os.Remove(filename)
112

113
	fileAsBytes, _, err := getMMapedFile(filename, 2, nil)
114

115
	require.NoError(t, err)
116
	copy(fileAsBytes, "ab")
117

118
	f, err := os.Open(filename)
119
	require.NoError(t, err)
120

121
	bytes := make([]byte, 4)
122
	n, err := f.Read(bytes)
123
	require.Equal(t, 2, n)
124
	require.NoError(t, err, "Unexpected error while reading file.")
125

126
	require.Equal(t, fileAsBytes, bytes[:2], "Mmap failed")
127
}
128

129
func TestParseBrokenJSON(t *testing.T) {
130
	for _, tc := range []struct {
131
		b []byte
132

133
		ok  bool
134
		out string
135
	}{
136
		{
137
			b: []byte(""),
138
		},
139
		{
140
			b: []byte("\x00\x00"),
141
		},
142
		{
143
			b: []byte("\x00[\x00"),
144
		},
145
		{
146
			b:   []byte("\x00[]\x00"),
147
			ok:  true,
148
			out: "[]",
149
		},
150
		{
151
			b:   []byte("[\"up == 0\",\"rate(http_requests[2w]\"]\x00\x00\x00"),
152
			ok:  true,
153
			out: "[\"up == 0\",\"rate(http_requests[2w]\"]",
154
		},
155
	} {
156
		t.Run("", func(t *testing.T) {
157
			out, ok := parseBrokenJSON(tc.b)
158
			require.Equal(t, tc.ok, ok)
159
			if ok {
160
				require.Equal(t, tc.out, out)
161
			}
162
		})
163
	}
164
}
165