2015-01-21 11:07:45 -08:00
|
|
|
// Copyright 2013 The Prometheus Authors
|
2013-02-08 05:49:55 -08: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.
|
|
|
|
|
|
|
|
package web
|
|
|
|
|
|
|
|
import (
|
2015-11-11 07:31:09 -08:00
|
|
|
"bytes"
|
2015-06-16 05:57:30 -07:00
|
|
|
"encoding/json"
|
2013-04-05 04:41:52 -07:00
|
|
|
"fmt"
|
2015-06-15 03:50:53 -07:00
|
|
|
"io"
|
2014-07-29 09:28:48 -07:00
|
|
|
"io/ioutil"
|
2015-06-30 05:38:01 -07:00
|
|
|
"net"
|
2013-02-08 05:49:55 -08:00
|
|
|
"net/http"
|
2015-06-15 03:50:53 -07:00
|
|
|
"net/url"
|
2013-08-09 09:09:44 -07:00
|
|
|
"os"
|
2017-05-22 05:15:02 -07:00
|
|
|
"path"
|
2015-06-15 03:50:53 -07:00
|
|
|
"path/filepath"
|
|
|
|
"sort"
|
2015-07-08 07:14:57 -07:00
|
|
|
"strings"
|
2015-06-15 03:50:53 -07:00
|
|
|
"sync"
|
2017-07-25 17:47:45 -07:00
|
|
|
"sync/atomic"
|
2013-08-29 06:15:22 -07:00
|
|
|
"time"
|
|
|
|
|
2017-07-06 05:38:40 -07:00
|
|
|
"google.golang.org/grpc"
|
|
|
|
|
2013-08-29 06:15:22 -07:00
|
|
|
pprof_runtime "runtime/pprof"
|
2015-06-23 08:46:50 -07:00
|
|
|
template_text "text/template"
|
2013-06-28 01:19:16 -07:00
|
|
|
|
2017-07-06 05:38:40 -07:00
|
|
|
"github.com/cockroachdb/cmux"
|
2017-05-02 16:49:29 -07:00
|
|
|
"github.com/opentracing-contrib/go-stdlib/nethttp"
|
|
|
|
"github.com/opentracing/opentracing-go"
|
2013-06-28 01:19:16 -07:00
|
|
|
"github.com/prometheus/client_golang/prometheus"
|
2015-10-03 01:21:43 -07:00
|
|
|
"github.com/prometheus/common/log"
|
2015-08-20 08:18:46 -07:00
|
|
|
"github.com/prometheus/common/model"
|
2015-09-24 08:07:11 -07:00
|
|
|
"github.com/prometheus/common/route"
|
2017-07-06 05:38:40 -07:00
|
|
|
"github.com/prometheus/prometheus/storage"
|
|
|
|
ptsdb "github.com/prometheus/prometheus/storage/tsdb"
|
|
|
|
"github.com/prometheus/tsdb"
|
promql: Allow per-query contexts.
For Weaveworks' Frankenstein, we need to support multitenancy. In
Frankenstein, we initially solved this without modifying the promql
package at all: we constructed a new promql.Engine for every
query and injected a storage implementation into that engine which would
be primed to only collect data for a given user.
This is problematic to upstream, however. Prometheus assumes that there
is only one engine: the query concurrency gate is part of the engine,
and the engine contains one central cancellable context to shut down all
queries. Also, creating a new engine for every query seems like overkill.
Thus, we want to be able to pass per-query contexts into a single engine.
This change gets rid of the promql.Engine's built-in base context and
allows passing in a per-query context instead. Central cancellation of
all queries is still possible by deriving all passed-in contexts from
one central one, but this is now the responsibility of the caller. The
central query context is now created in main() and passed into the
relevant components (web handler / API, rule manager).
In a next step, the per-query context would have to be passed to the
storage implementation, so that the storage can implement multi-tenancy
or other features based on the contextual information.
2016-09-15 04:52:50 -07:00
|
|
|
"golang.org/x/net/context"
|
2016-12-06 01:45:59 -08:00
|
|
|
"golang.org/x/net/netutil"
|
2013-06-28 01:19:16 -07:00
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
"github.com/prometheus/prometheus/config"
|
2016-11-23 09:23:09 -08:00
|
|
|
"github.com/prometheus/prometheus/notifier"
|
2017-04-04 05:44:39 -07:00
|
|
|
"github.com/prometheus/prometheus/pkg/labels"
|
2015-06-15 03:50:53 -07:00
|
|
|
"github.com/prometheus/prometheus/promql"
|
|
|
|
"github.com/prometheus/prometheus/retrieval"
|
|
|
|
"github.com/prometheus/prometheus/rules"
|
|
|
|
"github.com/prometheus/prometheus/template"
|
2015-09-17 05:49:50 -07:00
|
|
|
"github.com/prometheus/prometheus/util/httputil"
|
2016-06-23 08:14:32 -07:00
|
|
|
api_v1 "github.com/prometheus/prometheus/web/api/v1"
|
2017-07-10 06:44:29 -07:00
|
|
|
api_v2 "github.com/prometheus/prometheus/web/api/v2"
|
2015-11-11 07:31:09 -08:00
|
|
|
"github.com/prometheus/prometheus/web/ui"
|
2013-02-08 05:49:55 -08:00
|
|
|
)
|
|
|
|
|
2015-05-18 03:16:25 -07:00
|
|
|
var localhostRepresentations = []string{"127.0.0.1", "localhost"}
|
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
// Handler serves various HTTP endpoints of the Prometheus server
|
|
|
|
type Handler struct {
|
2016-05-13 08:59:59 -07:00
|
|
|
targetManager *retrieval.TargetManager
|
|
|
|
ruleManager *rules.Manager
|
|
|
|
queryEngine *promql.Engine
|
2016-09-15 15:58:06 -07:00
|
|
|
context context.Context
|
2017-07-06 05:38:40 -07:00
|
|
|
tsdb *tsdb.DB
|
2016-12-29 00:27:30 -08:00
|
|
|
storage storage.Storage
|
2016-11-23 09:23:09 -08:00
|
|
|
notifier *notifier.Notifier
|
2015-06-15 03:50:53 -07:00
|
|
|
|
2016-06-23 08:14:32 -07:00
|
|
|
apiV1 *api_v1.API
|
2015-06-15 03:50:53 -07:00
|
|
|
|
2016-05-13 08:59:59 -07:00
|
|
|
router *route.Router
|
|
|
|
quitCh chan struct{}
|
2016-07-11 07:24:54 -07:00
|
|
|
reloadCh chan chan error
|
2016-05-13 08:59:59 -07:00
|
|
|
options *Options
|
|
|
|
configString string
|
|
|
|
versionInfo *PrometheusVersion
|
|
|
|
birth time.Time
|
2016-12-03 15:37:59 -08:00
|
|
|
cwd string
|
2016-05-13 08:59:59 -07:00
|
|
|
flagsMap map[string]string
|
2015-06-15 03:50:53 -07:00
|
|
|
|
2015-09-29 08:51:03 -07:00
|
|
|
externalLabels model.LabelSet
|
|
|
|
mtx sync.RWMutex
|
2016-09-08 08:39:52 -07:00
|
|
|
now func() model.Time
|
2017-07-25 17:47:45 -07:00
|
|
|
|
|
|
|
ready uint32 // ready is uint32 rather than boolean to be able to use atomic functions.
|
2015-09-01 09:47:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// ApplyConfig updates the status state as the new config requires.
|
2016-07-11 07:24:54 -07:00
|
|
|
func (h *Handler) ApplyConfig(conf *config.Config) error {
|
2015-09-01 09:47:48 -07:00
|
|
|
h.mtx.Lock()
|
|
|
|
defer h.mtx.Unlock()
|
|
|
|
|
2015-09-29 08:51:03 -07:00
|
|
|
h.externalLabels = conf.GlobalConfig.ExternalLabels
|
2016-05-13 08:59:59 -07:00
|
|
|
h.configString = conf.String()
|
2015-09-01 09:47:48 -07:00
|
|
|
|
2016-07-11 07:24:54 -07:00
|
|
|
return nil
|
2015-06-15 03:50:53 -07:00
|
|
|
}
|
2013-02-08 06:38:50 -08:00
|
|
|
|
2016-05-13 08:59:59 -07:00
|
|
|
// PrometheusVersion contains build information about Prometheus.
|
2016-05-05 04:46:51 -07:00
|
|
|
type PrometheusVersion struct {
|
|
|
|
Version string `json:"version"`
|
|
|
|
Revision string `json:"revision"`
|
|
|
|
Branch string `json:"branch"`
|
|
|
|
BuildUser string `json:"buildUser"`
|
|
|
|
BuildDate string `json:"buildDate"`
|
|
|
|
GoVersion string `json:"goVersion"`
|
|
|
|
}
|
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
// Options for the web Handler.
|
|
|
|
type Options struct {
|
2016-09-15 15:58:06 -07:00
|
|
|
Context context.Context
|
2017-07-06 05:38:40 -07:00
|
|
|
Storage *tsdb.DB
|
2016-09-15 15:58:06 -07:00
|
|
|
QueryEngine *promql.Engine
|
|
|
|
TargetManager *retrieval.TargetManager
|
|
|
|
RuleManager *rules.Manager
|
2016-11-23 09:23:09 -08:00
|
|
|
Notifier *notifier.Notifier
|
2016-09-15 15:58:06 -07:00
|
|
|
Version *PrometheusVersion
|
|
|
|
Flags map[string]string
|
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
ListenAddress string
|
2016-12-01 05:29:45 -08:00
|
|
|
ReadTimeout time.Duration
|
2016-12-06 01:45:59 -08:00
|
|
|
MaxConnections int
|
2015-06-30 05:38:01 -07:00
|
|
|
ExternalURL *url.URL
|
2016-07-05 06:05:43 -07:00
|
|
|
RoutePrefix string
|
2017-07-06 05:38:40 -07:00
|
|
|
MetricsPath string
|
2015-06-15 03:50:53 -07:00
|
|
|
UseLocalAssets bool
|
|
|
|
UserAssetsPath string
|
|
|
|
ConsoleTemplatesPath string
|
|
|
|
ConsoleLibrariesPath string
|
2017-07-10 06:44:29 -07:00
|
|
|
EnableLifecycle bool
|
2017-07-10 00:29:41 -07:00
|
|
|
EnableAdminAPI bool
|
2015-06-15 03:50:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// New initializes a new web Handler.
|
2016-09-15 15:58:06 -07:00
|
|
|
func New(o *Options) *Handler {
|
2017-05-02 16:49:29 -07:00
|
|
|
router := route.New()
|
2016-12-03 15:37:59 -08:00
|
|
|
cwd, err := os.Getwd()
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
cwd = "<error retrieving current working directory>"
|
|
|
|
}
|
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
h := &Handler{
|
2015-08-20 09:23:57 -07:00
|
|
|
router: router,
|
|
|
|
quitCh: make(chan struct{}),
|
2016-07-11 07:24:54 -07:00
|
|
|
reloadCh: make(chan chan error),
|
2015-08-20 09:23:57 -07:00
|
|
|
options: o,
|
2016-09-15 15:58:06 -07:00
|
|
|
versionInfo: o.Version,
|
2016-05-13 08:59:59 -07:00
|
|
|
birth: time.Now(),
|
2016-12-03 15:37:59 -08:00
|
|
|
cwd: cwd,
|
2016-09-15 15:58:06 -07:00
|
|
|
flagsMap: o.Flags,
|
2015-06-15 03:50:53 -07:00
|
|
|
|
2016-09-15 15:58:06 -07:00
|
|
|
context: o.Context,
|
|
|
|
targetManager: o.TargetManager,
|
|
|
|
ruleManager: o.RuleManager,
|
|
|
|
queryEngine: o.QueryEngine,
|
2017-07-06 05:38:40 -07:00
|
|
|
tsdb: o.Storage,
|
|
|
|
storage: ptsdb.Adapter(o.Storage),
|
2016-11-23 09:23:09 -08:00
|
|
|
notifier: o.Notifier,
|
2015-06-15 03:50:53 -07:00
|
|
|
|
2016-09-08 08:39:52 -07:00
|
|
|
now: model.Now,
|
2017-07-25 17:47:45 -07:00
|
|
|
ready: 0,
|
2015-06-02 04:07:46 -07:00
|
|
|
}
|
2013-05-06 00:56:32 -07:00
|
|
|
|
2017-07-06 05:38:40 -07:00
|
|
|
h.apiV1 = api_v1.NewAPI(h.queryEngine, h.storage, h.targetManager, h.notifier)
|
|
|
|
|
2016-07-05 06:05:43 -07:00
|
|
|
if o.RoutePrefix != "/" {
|
2015-06-15 03:50:53 -07:00
|
|
|
// If the prefix is missing for the root path, prepend it.
|
2015-06-02 23:38:50 -07:00
|
|
|
router.Get("/", func(w http.ResponseWriter, r *http.Request) {
|
2016-07-05 06:05:43 -07:00
|
|
|
http.Redirect(w, r, o.RoutePrefix, http.StatusFound)
|
2015-06-02 23:38:50 -07:00
|
|
|
})
|
2016-07-05 06:05:43 -07:00
|
|
|
router = router.WithPrefix(o.RoutePrefix)
|
2015-06-02 23:38:50 -07:00
|
|
|
}
|
|
|
|
|
2015-09-17 07:33:14 -07:00
|
|
|
instrh := prometheus.InstrumentHandler
|
|
|
|
instrf := prometheus.InstrumentHandlerFunc
|
2017-07-25 17:47:45 -07:00
|
|
|
readyf := h.testReady
|
2015-06-02 23:38:50 -07:00
|
|
|
|
2015-08-28 01:53:13 -07:00
|
|
|
router.Get("/", func(w http.ResponseWriter, r *http.Request) {
|
2017-07-06 05:38:40 -07:00
|
|
|
router.Redirect(w, r, path.Join(o.ExternalURL.Path, "/graph"), http.StatusFound)
|
2015-08-28 01:53:13 -07:00
|
|
|
})
|
|
|
|
|
2017-07-25 17:47:45 -07:00
|
|
|
router.Get("/alerts", readyf(instrf("alerts", h.alerts)))
|
|
|
|
router.Get("/graph", readyf(instrf("graph", h.graph)))
|
|
|
|
router.Get("/status", readyf(instrf("status", h.status)))
|
|
|
|
router.Get("/flags", readyf(instrf("flags", h.flags)))
|
|
|
|
router.Get("/config", readyf(instrf("config", h.config)))
|
|
|
|
router.Get("/rules", readyf(instrf("rules", h.rules)))
|
|
|
|
router.Get("/targets", readyf(instrf("targets", h.targets)))
|
|
|
|
router.Get("/version", readyf(instrf("version", h.version)))
|
2015-06-02 23:38:50 -07:00
|
|
|
|
2017-07-25 17:47:45 -07:00
|
|
|
router.Get("/heap", readyf(instrf("heap", dumpHeap)))
|
2015-06-02 23:38:50 -07:00
|
|
|
|
2017-06-16 07:51:41 -07:00
|
|
|
router.Get("/metrics", prometheus.Handler().ServeHTTP)
|
2015-06-04 09:24:04 -07:00
|
|
|
|
2017-07-25 17:47:45 -07:00
|
|
|
router.Get("/federate", readyf(instrh("federate", httputil.CompressionHandler{
|
2015-09-18 07:51:53 -07:00
|
|
|
Handler: http.HandlerFunc(h.federation),
|
2017-07-25 17:47:45 -07:00
|
|
|
})))
|
2015-09-17 07:33:14 -07:00
|
|
|
|
2017-07-25 17:47:45 -07:00
|
|
|
router.Get("/consoles/*filepath", readyf(instrf("consoles", h.consoles)))
|
2015-06-02 23:38:50 -07:00
|
|
|
|
2017-07-25 17:47:45 -07:00
|
|
|
router.Get("/static/*filepath", readyf(instrf("static", serveStaticAsset)))
|
2013-02-08 05:49:55 -08:00
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
if o.UserAssetsPath != "" {
|
2017-07-25 17:47:45 -07:00
|
|
|
router.Get("/user/*filepath", readyf(instrf("user", route.FileServe(o.UserAssetsPath))))
|
2013-05-23 06:47:00 -07:00
|
|
|
}
|
|
|
|
|
2017-07-10 06:44:29 -07:00
|
|
|
if o.EnableLifecycle {
|
2015-06-15 03:50:53 -07:00
|
|
|
router.Post("/-/quit", h.quit)
|
2017-07-10 06:44:29 -07:00
|
|
|
router.Post("/-/reload", h.reload)
|
|
|
|
} else {
|
2017-08-10 07:28:49 -07:00
|
|
|
router.Post("/-/quit", readyf(func(w http.ResponseWriter, _ *http.Request) {
|
2017-07-10 06:44:29 -07:00
|
|
|
w.WriteHeader(http.StatusForbidden)
|
|
|
|
w.Write([]byte("Lifecycle APIs are not enabled"))
|
2017-08-10 07:28:49 -07:00
|
|
|
}))
|
|
|
|
router.Post("/-/reload", readyf(func(w http.ResponseWriter, _ *http.Request) {
|
2017-07-10 06:44:29 -07:00
|
|
|
w.WriteHeader(http.StatusForbidden)
|
|
|
|
w.Write([]byte("Lifecycle APIs are not enabled"))
|
2017-08-10 07:28:49 -07:00
|
|
|
}))
|
2015-03-24 14:04:38 -07:00
|
|
|
}
|
2017-07-10 06:44:29 -07:00
|
|
|
router.Get("/-/quit", func(w http.ResponseWriter, _ *http.Request) {
|
|
|
|
w.WriteHeader(http.StatusMethodNotAllowed)
|
|
|
|
w.Write([]byte("Only POST requests allowed"))
|
|
|
|
})
|
|
|
|
router.Get("/-/reload", func(w http.ResponseWriter, _ *http.Request) {
|
2016-11-07 07:14:22 -08:00
|
|
|
w.WriteHeader(http.StatusMethodNotAllowed)
|
2017-07-10 06:44:29 -07:00
|
|
|
w.Write([]byte("Only POST requests allowed"))
|
2016-11-07 07:14:22 -08:00
|
|
|
})
|
2015-08-26 08:42:25 -07:00
|
|
|
|
2017-07-25 17:47:45 -07:00
|
|
|
router.Get("/debug/*subpath", readyf(http.DefaultServeMux.ServeHTTP))
|
|
|
|
router.Post("/debug/*subpath", readyf(http.DefaultServeMux.ServeHTTP))
|
|
|
|
|
|
|
|
router.Get("/-/healthy", func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
fmt.Fprintf(w, "Prometheus is Healthy.\n")
|
|
|
|
})
|
|
|
|
router.Get("/-/ready", readyf(func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
fmt.Fprintf(w, "Prometheus is Ready.\n")
|
|
|
|
}))
|
2015-07-21 15:27:55 -07:00
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
return h
|
|
|
|
}
|
|
|
|
|
2017-07-06 05:38:40 -07:00
|
|
|
var corsHeaders = map[string]string{
|
|
|
|
"Access-Control-Allow-Headers": "Accept, Authorization, Content-Type, Origin",
|
|
|
|
"Access-Control-Allow-Methods": "GET, OPTIONS",
|
|
|
|
"Access-Control-Allow-Origin": "*",
|
|
|
|
"Access-Control-Expose-Headers": "Date",
|
|
|
|
}
|
|
|
|
|
|
|
|
// Enables cross-site script calls.
|
|
|
|
func setCORS(w http.ResponseWriter) {
|
|
|
|
for h, v := range corsHeaders {
|
|
|
|
w.Header().Set(h, v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-11 07:31:09 -08:00
|
|
|
func serveStaticAsset(w http.ResponseWriter, req *http.Request) {
|
2017-05-02 16:49:29 -07:00
|
|
|
fp := route.Param(req.Context(), "filepath")
|
2015-11-11 07:31:09 -08:00
|
|
|
fp = filepath.Join("web/ui/static", fp)
|
|
|
|
|
|
|
|
info, err := ui.AssetInfo(fp)
|
|
|
|
if err != nil {
|
|
|
|
log.With("file", fp).Warn("Could not get file info: ", err)
|
|
|
|
w.WriteHeader(http.StatusNotFound)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
file, err := ui.Asset(fp)
|
|
|
|
if err != nil {
|
|
|
|
if err != io.EOF {
|
|
|
|
log.With("file", fp).Warn("Could not get file: ", err)
|
|
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNotFound)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
http.ServeContent(w, req, info.Name(), info.ModTime(), bytes.NewReader(file))
|
|
|
|
}
|
|
|
|
|
2017-07-25 17:47:45 -07:00
|
|
|
// Ready sets Handler to be ready.
|
|
|
|
func (h *Handler) Ready() {
|
|
|
|
atomic.StoreUint32(&h.ready, 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verifies whether the server is ready or not.
|
|
|
|
func (h *Handler) isReady() bool {
|
|
|
|
ready := atomic.LoadUint32(&h.ready)
|
|
|
|
if ready == 0 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// Checks if server is ready, calls f if it is, returns 503 if it is not.
|
|
|
|
func (h *Handler) testReady(f http.HandlerFunc) http.HandlerFunc {
|
|
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
if h.isReady() {
|
|
|
|
f(w, r)
|
|
|
|
} else {
|
|
|
|
w.WriteHeader(http.StatusServiceUnavailable)
|
|
|
|
fmt.Fprintf(w, "Service Unavailable")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
// Quit returns the receive-only quit channel.
|
|
|
|
func (h *Handler) Quit() <-chan struct{} {
|
|
|
|
return h.quitCh
|
2015-06-02 04:07:46 -07:00
|
|
|
}
|
|
|
|
|
2015-08-20 09:23:57 -07:00
|
|
|
// Reload returns the receive-only channel that signals configuration reload requests.
|
2016-07-11 07:24:54 -07:00
|
|
|
func (h *Handler) Reload() <-chan chan error {
|
2015-08-11 00:08:17 -07:00
|
|
|
return h.reloadCh
|
|
|
|
}
|
|
|
|
|
2015-06-02 04:07:46 -07:00
|
|
|
// Run serves the HTTP endpoints.
|
2017-07-06 05:38:40 -07:00
|
|
|
func (h *Handler) Run(ctx context.Context) error {
|
2015-06-15 03:50:53 -07:00
|
|
|
log.Infof("Listening on %s", h.options.ListenAddress)
|
2017-07-06 05:38:40 -07:00
|
|
|
|
|
|
|
l, err := net.Listen("tcp", h.options.ListenAddress)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
l = netutil.LimitListener(l, h.options.MaxConnections)
|
|
|
|
|
|
|
|
var (
|
|
|
|
m = cmux.New(l)
|
|
|
|
grpcl = m.Match(cmux.HTTP2HeaderField("content-type", "application/grpc"))
|
|
|
|
httpl = m.Match(cmux.HTTP1Fast())
|
|
|
|
grpcSrv = grpc.NewServer()
|
|
|
|
)
|
2017-07-10 06:44:29 -07:00
|
|
|
av2 := api_v2.New(
|
2017-07-06 05:38:40 -07:00
|
|
|
time.Now,
|
|
|
|
h.options.Storage,
|
|
|
|
h.options.QueryEngine,
|
|
|
|
func(mint, maxt int64) storage.Querier {
|
|
|
|
q, err := ptsdb.Adapter(h.options.Storage).Querier(mint, maxt)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
return q
|
|
|
|
},
|
|
|
|
func() []*retrieval.Target {
|
|
|
|
return h.options.TargetManager.Targets()
|
|
|
|
},
|
|
|
|
func() []*url.URL {
|
|
|
|
return h.options.Notifier.Alertmanagers()
|
|
|
|
},
|
2017-07-10 00:29:41 -07:00
|
|
|
h.options.EnableAdminAPI,
|
2017-07-06 05:38:40 -07:00
|
|
|
)
|
|
|
|
av2.RegisterGRPC(grpcSrv)
|
|
|
|
|
|
|
|
hh, err := av2.HTTPHandler(grpcl.Addr().String())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-05-02 16:49:29 -07:00
|
|
|
operationName := nethttp.OperationNameFunc(func(r *http.Request) string {
|
|
|
|
return fmt.Sprintf("%s %s", r.Method, r.URL.Path)
|
|
|
|
})
|
2017-07-06 05:38:40 -07:00
|
|
|
mux := http.NewServeMux()
|
|
|
|
mux.Handle("/", h.router)
|
|
|
|
|
|
|
|
av1 := route.New()
|
|
|
|
h.apiV1.Register(av1)
|
|
|
|
mux.Handle("/api/v1/", http.StripPrefix("/api/v1", av1))
|
|
|
|
|
|
|
|
mux.Handle("/api/", http.StripPrefix("/api",
|
|
|
|
http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
setCORS(w)
|
|
|
|
hh.ServeHTTP(w, r)
|
|
|
|
}),
|
|
|
|
))
|
|
|
|
|
|
|
|
httpSrv := &http.Server{
|
|
|
|
Handler: nethttp.Middleware(opentracing.GlobalTracer(), mux, operationName),
|
2016-12-01 05:29:45 -08:00
|
|
|
ErrorLog: log.NewErrorLogger(),
|
|
|
|
ReadTimeout: h.options.ReadTimeout,
|
2016-05-25 04:13:22 -07:00
|
|
|
}
|
2017-07-06 05:38:40 -07:00
|
|
|
|
2017-08-10 05:48:31 -07:00
|
|
|
go func() {
|
|
|
|
if err := httpSrv.Serve(httpl); err != nil {
|
|
|
|
log.With("err", err).Warnf("error serving HTTP")
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
go func() {
|
|
|
|
if err := grpcSrv.Serve(grpcl); err != nil {
|
|
|
|
log.With("err", err).Warnf("error serving HTTP")
|
|
|
|
}
|
|
|
|
}()
|
2017-07-06 05:38:40 -07:00
|
|
|
|
|
|
|
return m.Serve()
|
2013-02-08 05:49:55 -08:00
|
|
|
}
|
2013-03-27 09:40:01 -07:00
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
func (h *Handler) alerts(w http.ResponseWriter, r *http.Request) {
|
|
|
|
alerts := h.ruleManager.AlertingRules()
|
2016-12-27 05:13:33 -08:00
|
|
|
alertsSorter := byAlertStateAndNameSorter{alerts: alerts}
|
2015-06-15 03:50:53 -07:00
|
|
|
sort.Sort(alertsSorter)
|
|
|
|
|
|
|
|
alertStatus := AlertStatus{
|
|
|
|
AlertingRules: alertsSorter.alerts,
|
|
|
|
AlertStateToRowClass: map[rules.AlertState]string{
|
|
|
|
rules.StateInactive: "success",
|
|
|
|
rules.StatePending: "warning",
|
|
|
|
rules.StateFiring: "danger",
|
|
|
|
},
|
|
|
|
}
|
2015-11-11 07:31:09 -08:00
|
|
|
h.executeTemplate(w, "alerts.html", alertStatus)
|
2015-06-15 03:50:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func (h *Handler) consoles(w http.ResponseWriter, r *http.Request) {
|
2017-05-02 16:49:29 -07:00
|
|
|
ctx := r.Context()
|
2015-06-15 03:50:53 -07:00
|
|
|
name := route.Param(ctx, "filepath")
|
|
|
|
|
|
|
|
file, err := http.Dir(h.options.ConsoleTemplatesPath).Open(name)
|
|
|
|
if err != nil {
|
|
|
|
http.Error(w, err.Error(), http.StatusNotFound)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
text, err := ioutil.ReadAll(file)
|
|
|
|
if err != nil {
|
|
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Provide URL parameters as a map for easy use. Advanced users may have need for
|
|
|
|
// parameters beyond the first, so provide RawParams.
|
|
|
|
rawParams, err := url.ParseQuery(r.URL.RawQuery)
|
|
|
|
if err != nil {
|
|
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
params := map[string]string{}
|
|
|
|
for k, v := range rawParams {
|
|
|
|
params[k] = v[0]
|
|
|
|
}
|
|
|
|
data := struct {
|
|
|
|
RawParams url.Values
|
|
|
|
Params map[string]string
|
|
|
|
Path string
|
|
|
|
}{
|
|
|
|
RawParams: rawParams,
|
|
|
|
Params: params,
|
2015-07-08 07:14:57 -07:00
|
|
|
Path: strings.TrimLeft(name, "/"),
|
2015-06-15 03:50:53 -07:00
|
|
|
}
|
|
|
|
|
2017-05-13 06:47:04 -07:00
|
|
|
tmpl := template.NewTemplateExpander(h.context, string(text), "__console_"+name, data, h.now(), h.queryEngine, h.options.ExternalURL)
|
2015-06-15 03:50:53 -07:00
|
|
|
filenames, err := filepath.Glob(h.options.ConsoleLibrariesPath + "/*.lib")
|
|
|
|
if err != nil {
|
|
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
result, err := tmpl.ExpandHTML(filenames)
|
|
|
|
if err != nil {
|
|
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
io.WriteString(w, result)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (h *Handler) graph(w http.ResponseWriter, r *http.Request) {
|
2015-11-11 07:31:09 -08:00
|
|
|
h.executeTemplate(w, "graph.html", nil)
|
2015-06-15 03:50:53 -07:00
|
|
|
}
|
|
|
|
|
2015-06-16 05:57:30 -07:00
|
|
|
func (h *Handler) status(w http.ResponseWriter, r *http.Request) {
|
2015-11-11 07:31:09 -08:00
|
|
|
h.executeTemplate(w, "status.html", struct {
|
2016-11-23 09:23:09 -08:00
|
|
|
Birth time.Time
|
2016-12-03 15:37:59 -08:00
|
|
|
CWD string
|
2016-11-23 09:23:09 -08:00
|
|
|
Version *PrometheusVersion
|
2017-04-24 22:42:33 -07:00
|
|
|
Alertmanagers []*url.URL
|
2015-06-15 03:23:02 -07:00
|
|
|
}{
|
2016-11-23 09:23:09 -08:00
|
|
|
Birth: h.birth,
|
2016-12-03 15:37:59 -08:00
|
|
|
CWD: h.cwd,
|
2016-11-23 09:23:09 -08:00
|
|
|
Version: h.versionInfo,
|
|
|
|
Alertmanagers: h.notifier.Alertmanagers(),
|
2015-06-15 03:23:02 -07:00
|
|
|
})
|
2015-06-15 03:50:53 -07:00
|
|
|
}
|
2014-04-14 16:02:15 -07:00
|
|
|
|
2016-05-13 08:59:59 -07:00
|
|
|
func (h *Handler) flags(w http.ResponseWriter, r *http.Request) {
|
|
|
|
h.executeTemplate(w, "flags.html", h.flagsMap)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (h *Handler) config(w http.ResponseWriter, r *http.Request) {
|
|
|
|
h.mtx.RLock()
|
|
|
|
defer h.mtx.RUnlock()
|
|
|
|
|
|
|
|
h.executeTemplate(w, "config.html", h.configString)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (h *Handler) rules(w http.ResponseWriter, r *http.Request) {
|
|
|
|
h.executeTemplate(w, "rules.html", h.ruleManager)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (h *Handler) targets(w http.ResponseWriter, r *http.Request) {
|
2016-12-02 04:28:58 -08:00
|
|
|
// Bucket targets by job label
|
2017-01-06 09:43:41 -08:00
|
|
|
tps := map[string][]*retrieval.Target{}
|
2016-12-02 04:28:58 -08:00
|
|
|
for _, t := range h.targetManager.Targets() {
|
2016-12-29 00:27:30 -08:00
|
|
|
job := t.Labels().Get(model.JobLabel)
|
2016-12-02 04:28:58 -08:00
|
|
|
tps[job] = append(tps[job], t)
|
|
|
|
}
|
|
|
|
|
2017-03-30 13:45:18 -07:00
|
|
|
for _, targets := range tps {
|
|
|
|
sort.Slice(targets, func(i, j int) bool {
|
2017-04-04 05:44:39 -07:00
|
|
|
return targets[i].Labels().Get(labels.InstanceName) < targets[j].Labels().Get(labels.InstanceName)
|
2017-03-30 13:45:18 -07:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2016-11-23 09:23:09 -08:00
|
|
|
h.executeTemplate(w, "targets.html", struct {
|
2017-01-06 09:43:41 -08:00
|
|
|
TargetPools map[string][]*retrieval.Target
|
2016-11-23 09:23:09 -08:00
|
|
|
}{
|
2016-12-02 04:28:58 -08:00
|
|
|
TargetPools: tps,
|
2016-11-23 09:23:09 -08:00
|
|
|
})
|
2016-05-13 08:59:59 -07:00
|
|
|
}
|
|
|
|
|
2015-06-16 05:57:30 -07:00
|
|
|
func (h *Handler) version(w http.ResponseWriter, r *http.Request) {
|
|
|
|
dec := json.NewEncoder(w)
|
2016-05-05 04:46:51 -07:00
|
|
|
if err := dec.Encode(h.versionInfo); err != nil {
|
2015-06-16 05:57:30 -07:00
|
|
|
http.Error(w, fmt.Sprintf("error encoding JSON: %s", err), http.StatusInternalServerError)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
func (h *Handler) quit(w http.ResponseWriter, r *http.Request) {
|
|
|
|
fmt.Fprintf(w, "Requesting termination... Goodbye!")
|
|
|
|
close(h.quitCh)
|
2014-04-14 16:02:15 -07:00
|
|
|
}
|
|
|
|
|
2015-08-11 00:08:17 -07:00
|
|
|
func (h *Handler) reload(w http.ResponseWriter, r *http.Request) {
|
2016-07-11 07:24:54 -07:00
|
|
|
rc := make(chan error)
|
|
|
|
h.reloadCh <- rc
|
|
|
|
if err := <-rc; err != nil {
|
|
|
|
http.Error(w, fmt.Sprintf("failed to reload config: %s", err), http.StatusInternalServerError)
|
|
|
|
}
|
2015-08-11 00:08:17 -07:00
|
|
|
}
|
|
|
|
|
2015-06-30 05:38:01 -07:00
|
|
|
func (h *Handler) consolesPath() string {
|
2015-06-15 03:50:53 -07:00
|
|
|
if _, err := os.Stat(h.options.ConsoleTemplatesPath + "/index.html"); !os.IsNotExist(err) {
|
2015-06-30 05:38:01 -07:00
|
|
|
return h.options.ExternalURL.Path + "/consoles/index.html"
|
2014-10-02 07:44:47 -07:00
|
|
|
}
|
2015-06-15 03:50:53 -07:00
|
|
|
if h.options.UserAssetsPath != "" {
|
|
|
|
if _, err := os.Stat(h.options.UserAssetsPath + "/index.html"); !os.IsNotExist(err) {
|
2015-06-30 05:38:01 -07:00
|
|
|
return h.options.ExternalURL.Path + "/user/index.html"
|
2014-10-02 07:44:47 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2015-06-30 05:38:01 -07:00
|
|
|
func tmplFuncs(consolesPath string, opts *Options) template_text.FuncMap {
|
|
|
|
return template_text.FuncMap{
|
2016-06-08 11:23:54 -07:00
|
|
|
"since": func(t time.Time) time.Duration {
|
|
|
|
return time.Since(t) / time.Millisecond * time.Millisecond
|
|
|
|
},
|
2015-06-30 05:38:01 -07:00
|
|
|
"consolesPath": func() string { return consolesPath },
|
|
|
|
"pathPrefix": func() string { return opts.ExternalURL.Path },
|
2017-03-18 13:38:35 -07:00
|
|
|
"buildVersion": func() string { return opts.Version.Revision },
|
2017-03-20 06:07:41 -07:00
|
|
|
"stripLabels": func(lset map[string]string, labels ...string) map[string]string {
|
2015-05-18 03:16:25 -07:00
|
|
|
for _, ln := range labels {
|
|
|
|
delete(lset, ln)
|
|
|
|
}
|
|
|
|
return lset
|
|
|
|
},
|
2015-06-22 13:57:32 -07:00
|
|
|
"globalURL": func(u *url.URL) *url.URL {
|
2015-06-30 05:38:01 -07:00
|
|
|
host, port, err := net.SplitHostPort(u.Host)
|
|
|
|
if err != nil {
|
|
|
|
return u
|
|
|
|
}
|
2015-06-22 13:57:32 -07:00
|
|
|
for _, lhr := range localhostRepresentations {
|
2015-06-30 05:38:01 -07:00
|
|
|
if host == lhr {
|
|
|
|
_, ownPort, err := net.SplitHostPort(opts.ListenAddress)
|
|
|
|
if err != nil {
|
|
|
|
return u
|
|
|
|
}
|
|
|
|
|
|
|
|
if port == ownPort {
|
|
|
|
// Only in the case where the target is on localhost and its port is
|
|
|
|
// the same as the one we're listening on, we know for sure that
|
|
|
|
// we're monitoring our own process and that we need to change the
|
|
|
|
// scheme, hostname, and port to the externally reachable ones as
|
|
|
|
// well. We shouldn't need to touch the path at all, since if a
|
|
|
|
// path prefix is defined, the path under which we scrape ourselves
|
|
|
|
// should already contain the prefix.
|
|
|
|
u.Scheme = opts.ExternalURL.Scheme
|
|
|
|
u.Host = opts.ExternalURL.Host
|
|
|
|
} else {
|
|
|
|
// Otherwise, we only know that localhost is not reachable
|
|
|
|
// externally, so we replace only the hostname by the one in the
|
|
|
|
// external URL. It could be the wrong hostname for the service on
|
|
|
|
// this port, but it's still the best possible guess.
|
|
|
|
host, _, err := net.SplitHostPort(opts.ExternalURL.Host)
|
|
|
|
if err != nil {
|
|
|
|
return u
|
|
|
|
}
|
|
|
|
u.Host = host + ":" + port
|
|
|
|
}
|
|
|
|
break
|
2015-06-22 13:57:32 -07:00
|
|
|
}
|
2015-05-18 03:16:25 -07:00
|
|
|
}
|
2015-06-22 13:57:32 -07:00
|
|
|
return u
|
2015-05-18 03:16:25 -07:00
|
|
|
},
|
2017-08-09 08:10:30 -07:00
|
|
|
"numHealthy": func(pool []*retrieval.Target) int {
|
|
|
|
alive := len(pool)
|
|
|
|
for _, p := range pool {
|
|
|
|
if p.Health() != retrieval.HealthGood {
|
|
|
|
alive--
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return alive
|
|
|
|
},
|
2015-06-15 03:50:53 -07:00
|
|
|
"healthToClass": func(th retrieval.TargetHealth) string {
|
|
|
|
switch th {
|
|
|
|
case retrieval.HealthUnknown:
|
|
|
|
return "warning"
|
|
|
|
case retrieval.HealthGood:
|
|
|
|
return "success"
|
|
|
|
default:
|
|
|
|
return "danger"
|
|
|
|
}
|
|
|
|
},
|
2015-06-23 08:46:50 -07:00
|
|
|
"alertStateToClass": func(as rules.AlertState) string {
|
|
|
|
switch as {
|
|
|
|
case rules.StateInactive:
|
|
|
|
return "success"
|
|
|
|
case rules.StatePending:
|
|
|
|
return "warning"
|
|
|
|
case rules.StateFiring:
|
|
|
|
return "danger"
|
|
|
|
default:
|
|
|
|
panic("unknown alert state")
|
|
|
|
}
|
|
|
|
},
|
2015-06-30 05:38:01 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-11 07:31:09 -08:00
|
|
|
func (h *Handler) getTemplate(name string) (string, error) {
|
|
|
|
baseTmpl, err := ui.Asset("web/ui/templates/_base.html")
|
|
|
|
if err != nil {
|
|
|
|
return "", fmt.Errorf("error reading base template: %s", err)
|
|
|
|
}
|
|
|
|
pageTmpl, err := ui.Asset(filepath.Join("web/ui/templates", name))
|
|
|
|
if err != nil {
|
|
|
|
return "", fmt.Errorf("error reading page template %s: %s", name, err)
|
|
|
|
}
|
|
|
|
return string(baseTmpl) + string(pageTmpl), nil
|
|
|
|
}
|
|
|
|
|
2015-06-30 05:38:01 -07:00
|
|
|
func (h *Handler) executeTemplate(w http.ResponseWriter, name string, data interface{}) {
|
|
|
|
text, err := h.getTemplate(name)
|
|
|
|
if err != nil {
|
|
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
|
|
}
|
|
|
|
|
2017-05-13 06:47:04 -07:00
|
|
|
tmpl := template.NewTemplateExpander(h.context, text, name, data, h.now(), h.queryEngine, h.options.ExternalURL)
|
2015-06-30 05:38:01 -07:00
|
|
|
tmpl.Funcs(tmplFuncs(h.consolesPath(), h.options))
|
2015-05-18 03:16:25 -07:00
|
|
|
|
2015-06-23 08:46:50 -07:00
|
|
|
result, err := tmpl.ExpandHTML(nil)
|
2013-03-27 09:40:01 -07:00
|
|
|
if err != nil {
|
2015-06-23 08:46:50 -07:00
|
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
2013-03-27 09:40:01 -07:00
|
|
|
return
|
|
|
|
}
|
2015-06-23 08:46:50 -07:00
|
|
|
io.WriteString(w, result)
|
2013-03-27 09:40:01 -07:00
|
|
|
}
|
2013-08-09 09:09:44 -07:00
|
|
|
|
2013-08-29 06:15:22 -07:00
|
|
|
func dumpHeap(w http.ResponseWriter, r *http.Request) {
|
|
|
|
target := fmt.Sprintf("/tmp/%d.heap", time.Now().Unix())
|
|
|
|
f, err := os.Create(target)
|
|
|
|
if err != nil {
|
2015-05-20 09:10:29 -07:00
|
|
|
log.Error("Could not dump heap: ", err)
|
2013-08-29 06:15:22 -07:00
|
|
|
}
|
|
|
|
fmt.Fprintf(w, "Writing to %s...", target)
|
|
|
|
defer f.Close()
|
|
|
|
pprof_runtime.WriteHeapProfile(f)
|
|
|
|
fmt.Fprintf(w, "Done")
|
|
|
|
}
|
|
|
|
|
2015-06-15 03:50:53 -07:00
|
|
|
// AlertStatus bundles alerting rules and the mapping of alert states to row classes.
|
|
|
|
type AlertStatus struct {
|
|
|
|
AlertingRules []*rules.AlertingRule
|
|
|
|
AlertStateToRowClass map[rules.AlertState]string
|
2013-08-09 09:09:44 -07:00
|
|
|
}
|
2015-05-22 03:29:33 -07:00
|
|
|
|
2016-12-27 05:13:33 -08:00
|
|
|
type byAlertStateAndNameSorter struct {
|
2015-06-15 03:50:53 -07:00
|
|
|
alerts []*rules.AlertingRule
|
|
|
|
}
|
|
|
|
|
2016-12-27 05:13:33 -08:00
|
|
|
func (s byAlertStateAndNameSorter) Len() int {
|
2015-06-15 03:50:53 -07:00
|
|
|
return len(s.alerts)
|
|
|
|
}
|
|
|
|
|
2016-12-27 05:13:33 -08:00
|
|
|
func (s byAlertStateAndNameSorter) Less(i, j int) bool {
|
|
|
|
return s.alerts[i].State() > s.alerts[j].State() ||
|
|
|
|
(s.alerts[i].State() == s.alerts[j].State() &&
|
|
|
|
s.alerts[i].Name() < s.alerts[j].Name())
|
2015-06-15 03:50:53 -07:00
|
|
|
}
|
|
|
|
|
2016-12-27 05:13:33 -08:00
|
|
|
func (s byAlertStateAndNameSorter) Swap(i, j int) {
|
2015-06-15 03:50:53 -07:00
|
|
|
s.alerts[i], s.alerts[j] = s.alerts[j], s.alerts[i]
|
2015-05-22 03:29:33 -07:00
|
|
|
}
|