2015-01-21 11:07:45 -08:00
|
|
|
// Copyright 2014 The Prometheus Authors
|
2014-09-19 09:18:44 -07:00
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
2014-11-27 09:04:48 -08:00
|
|
|
// NOTE ON FILENAME: Do not rename this file helpers_test.go (which might appear
|
|
|
|
// an obvious choice). We need NewTestStorage in tests outside of the local
|
|
|
|
// package, too. On the other hand, moving NewTestStorage in its own package
|
|
|
|
// would cause circular dependencies in the tests in packages local.
|
|
|
|
|
2014-09-16 06:47:24 -07:00
|
|
|
package local
|
2014-06-06 02:55:53 -07:00
|
|
|
|
|
|
|
import (
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/prometheus/prometheus/utility/test"
|
|
|
|
)
|
|
|
|
|
|
|
|
type testStorageCloser struct {
|
|
|
|
storage Storage
|
|
|
|
directory test.Closer
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *testStorageCloser) Close() {
|
2014-10-24 11:27:27 -07:00
|
|
|
t.storage.Stop()
|
2014-06-06 02:55:53 -07:00
|
|
|
t.directory.Close()
|
|
|
|
}
|
|
|
|
|
2014-09-16 06:47:24 -07:00
|
|
|
// NewTestStorage creates a storage instance backed by files in a temporary
|
|
|
|
// directory. The returned storage is already in serving state. Upon closing the
|
|
|
|
// returned test.Closer, the temporary directory is cleaned up.
|
2014-11-27 09:04:48 -08:00
|
|
|
func NewTestStorage(t test.T) (Storage, test.Closer) {
|
2014-06-06 02:55:53 -07:00
|
|
|
directory := test.NewTemporaryDirectory("test_storage", t)
|
|
|
|
o := &MemorySeriesStorageOptions{
|
2014-11-13 11:50:25 -08:00
|
|
|
MemoryChunks: 1000000,
|
Improve persisting chunks to disk.
This is done by bucketing chunks by fingerprint. If the persisting to
disk falls behind, more and more chunks are in the queue. As soon as
there are "double hits", we will now persist both chunks in one go,
doubling the disk throughput (assuming it is limited by disk
seeks). Should even more pile up so that we end wit "triple hits", we
will persist those first, and so on.
Even if we have millions of time series, this will still help,
assuming not all of them are growing with the same speed. Series that
get many samples and/or are not very compressable will accumulate
chunks faster, and they will soon get double- or triple-writes.
To improve the chance of double writes,
-storage.local.persistence-queue-capacity could be set to a higher
value. However, that will slow down shutdown a lot (as the queue has
to be worked through). So we leave it to the user to set it to a
really high value. A more fundamental solution would be to checkpoint
not only head chunks, but also chunks still in the persist queue. That
would be quite complicated for a rather limited use-case (running many
time series with high ingestion rate on slow spinning disks).
2015-02-13 11:08:52 -08:00
|
|
|
PersistenceRetentionPeriod: 24 * time.Hour * 365 * 100, // Enough to never trigger purging.
|
2014-10-07 10:11:24 -07:00
|
|
|
PersistenceStoragePath: directory.Path(),
|
2014-10-24 11:27:27 -07:00
|
|
|
CheckpointInterval: time.Hour,
|
2014-06-06 02:55:53 -07:00
|
|
|
}
|
|
|
|
storage, err := NewMemorySeriesStorage(o)
|
|
|
|
if err != nil {
|
|
|
|
directory.Close()
|
|
|
|
t.Fatalf("Error creating storage: %s", err)
|
|
|
|
}
|
|
|
|
|
2014-10-24 11:27:27 -07:00
|
|
|
storage.Start()
|
2014-06-06 02:55:53 -07:00
|
|
|
|
|
|
|
closer := &testStorageCloser{
|
|
|
|
storage: storage,
|
|
|
|
directory: directory,
|
|
|
|
}
|
|
|
|
|
|
|
|
return storage, closer
|
|
|
|
}
|