From b24e5d63bcc0904c85721b57422244a1a1985aae Mon Sep 17 00:00:00 2001 From: Julius Volz Date: Sat, 10 Sep 2016 02:28:19 +0200 Subject: [PATCH] Add noop local storage engine. This adds a flag -storage.local.engine which allows turning off local storage in Prometheus. Instead of adding if-conditions and nil checks to all parts of Prometheus that deal with Prometheus's local storage (including the web interface), disabling local storage simply means replacing the normal local storage with a noop version that throws samples away and returns empty query results. We also don't add the noop storage to the fanout appender to decrease internal overhead. Instead of returning empty results, an alternate behavior could be to return errors on any query that point out that the local storage is disabled. Not sure which one is more preferable, so I went with the empty result option for now. --- cmd/prometheus/config.go | 15 ++++--- cmd/prometheus/main.go | 30 +++++++++---- storage/local/noop_storage.go | 82 +++++++++++++++++++++++++++++++++++ 3 files changed, 113 insertions(+), 14 deletions(-) create mode 100644 storage/local/noop_storage.go diff --git a/cmd/prometheus/config.go b/cmd/prometheus/config.go index 45042ded9..3e6ed70b2 100644 --- a/cmd/prometheus/config.go +++ b/cmd/prometheus/config.go @@ -43,11 +43,12 @@ var cfg = struct { printVersion bool configFile string - storage local.MemorySeriesStorageOptions - notifier notifier.Options - queryEngine promql.EngineOptions - web web.Options - remote remote.Options + storage local.MemorySeriesStorageOptions + localStorageEngine string + notifier notifier.Options + queryEngine promql.EngineOptions + web web.Options + remote remote.Options alertmanagerURLs stringset prometheusURL string @@ -172,6 +173,10 @@ func init() { &cfg.storage.NumMutexes, "storage.local.num-fingerprint-mutexes", 4096, "The number of mutexes used for fingerprint locking.", ) + cfg.fs.StringVar( + &cfg.localStorageEngine, "storage.local.engine", "persisted", + "Local storage engine. Supported values are: 'persisted' (full local storage with on-disk persistence) and 'none' (no local storage).", + ) // Remote storage. cfg.fs.StringVar( diff --git a/cmd/prometheus/main.go b/cmd/prometheus/main.go index 8f7b65bdc..b54e72e28 100644 --- a/cmd/prometheus/main.go +++ b/cmd/prometheus/main.go @@ -73,13 +73,23 @@ func Main() int { log.Infoln("Starting prometheus", version.Info()) log.Infoln("Build context", version.BuildContext()) - var reloadables []Reloadable - var ( - memStorage = local.NewMemorySeriesStorage(&cfg.storage) - sampleAppender = storage.Fanout{memStorage} + sampleAppender = storage.Fanout{} + reloadables []Reloadable ) + var localStorage local.Storage + switch cfg.localStorageEngine { + case "persisted": + localStorage = local.NewMemorySeriesStorage(&cfg.storage) + sampleAppender = storage.Fanout{localStorage} + case "none": + localStorage = &local.NoopStorage{} + default: + log.Errorf("Invalid local storage engine %q", cfg.localStorageEngine) + return 1 + } + remoteStorage, err := remote.New(&cfg.remote) if err != nil { log.Errorf("Error initializing remote storage: %s", err) @@ -94,7 +104,7 @@ func Main() int { var ( notifier = notifier.New(&cfg.notifier) targetManager = retrieval.NewTargetManager(sampleAppender) - queryEngine = promql.NewEngine(memStorage, &cfg.queryEngine) + queryEngine = promql.NewEngine(localStorage, &cfg.queryEngine) ) ruleManager := rules.NewManager(&rules.ManagerOptions{ @@ -118,7 +128,7 @@ func Main() int { GoVersion: version.GoVersion, } - webHandler := web.New(memStorage, queryEngine, targetManager, ruleManager, version, flags, &cfg.web) + webHandler := web.New(localStorage, queryEngine, targetManager, ruleManager, version, flags, &cfg.web) reloadables = append(reloadables, targetManager, ruleManager, webHandler, notifier) @@ -154,12 +164,12 @@ func Main() int { // Start all components. The order is NOT arbitrary. - if err := memStorage.Start(); err != nil { + if err := localStorage.Start(); err != nil { log.Errorln("Error opening memory series storage:", err) return 1 } defer func() { - if err := memStorage.Stop(); err != nil { + if err := localStorage.Stop(); err != nil { log.Errorln("Error stopping storage:", err) } }() @@ -171,7 +181,9 @@ func Main() int { defer remoteStorage.Stop() } // The storage has to be fully initialized before registering. - prometheus.MustRegister(memStorage) + if instrumentedStorage, ok := localStorage.(prometheus.Collector); ok { + prometheus.MustRegister(instrumentedStorage) + } prometheus.MustRegister(notifier) prometheus.MustRegister(configSuccess) prometheus.MustRegister(configSuccessTime) diff --git a/storage/local/noop_storage.go b/storage/local/noop_storage.go new file mode 100644 index 000000000..4832f8f45 --- /dev/null +++ b/storage/local/noop_storage.go @@ -0,0 +1,82 @@ +// Copyright 2016 The Prometheus Authors +// 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. + +package local + +import ( + "time" + + "github.com/prometheus/common/model" + "github.com/prometheus/prometheus/storage/metric" +) + +// NoopStorage is a dummy storage for use when Prometheus's local storage is +// disabled. It throws away any appended samples and returns empty results. +type NoopStorage struct{} + +// Start implements Storage. +func (s *NoopStorage) Start() (err error) { + return nil +} + +// Stop implements Storage. +func (s *NoopStorage) Stop() error { + return nil +} + +// WaitForIndexing implements Storage. +func (s *NoopStorage) WaitForIndexing() { +} + +// LastSampleForLabelMatchers implements Storage. +func (s *NoopStorage) LastSampleForLabelMatchers(cutoff model.Time, matcherSets ...metric.LabelMatchers) (model.Vector, error) { + return nil, nil +} + +// QueryRange implements Storage. +func (s *NoopStorage) QueryRange(from, through model.Time, matchers ...*metric.LabelMatcher) ([]SeriesIterator, error) { + return nil, nil +} + +// QueryInstant implements Storage. +func (s *NoopStorage) QueryInstant(ts model.Time, stalenessDelta time.Duration, matchers ...*metric.LabelMatcher) ([]SeriesIterator, error) { + return nil, nil +} + +// MetricsForLabelMatchers implements Storage. +func (s *NoopStorage) MetricsForLabelMatchers( + from, through model.Time, + matcherSets ...metric.LabelMatchers, +) ([]metric.Metric, error) { + return nil, nil +} + +// LabelValuesForLabelName implements Storage. +func (s *NoopStorage) LabelValuesForLabelName(labelName model.LabelName) (model.LabelValues, error) { + return nil, nil +} + +// DropMetricsForLabelMatchers implements Storage. +func (s *NoopStorage) DropMetricsForLabelMatchers(matchers ...*metric.LabelMatcher) (int, error) { + return 0, nil +} + +// Append implements Storage. +func (s *NoopStorage) Append(sample *model.Sample) error { + return nil +} + +// NeedsThrottling implements Storage. +func (s *NoopStorage) NeedsThrottling() bool { + return false +}