forked from mirror/client_golang
202 lines
6.7 KiB
Go
202 lines
6.7 KiB
Go
![]() |
// 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.
|
||
|
|
||
|
// Copyright (c) 2013, The Prometheus Authors
|
||
|
// All rights reserved.
|
||
|
//
|
||
|
// Use of this source code is governed by a BSD-style license that can be found
|
||
|
// in the LICENSE file.
|
||
|
|
||
|
// Package promhttp contains functions to create http.Handler instances to
|
||
|
// expose Prometheus metrics via HTTP. In later versions of this package, it
|
||
|
// will also contain tooling to instrument instances of http.Handler and
|
||
|
// http.RoundTripper.
|
||
|
//
|
||
|
// promhttp.Handler acts on the prometheus.DefaultDeliverer. With HandlerFor,
|
||
|
// you can create a handler for a custom registry or anything that implements
|
||
|
// the Deliverer interface. It also allows to create handlers that act
|
||
|
// differently on errors or allow to log errors.
|
||
|
package promhttp
|
||
|
|
||
|
import (
|
||
|
"bytes"
|
||
|
"compress/gzip"
|
||
|
"fmt"
|
||
|
"io"
|
||
|
"net/http"
|
||
|
"strings"
|
||
|
"sync"
|
||
|
|
||
|
"github.com/prometheus/common/expfmt"
|
||
|
|
||
|
"github.com/prometheus/client_golang/prometheus"
|
||
|
)
|
||
|
|
||
|
const (
|
||
|
contentTypeHeader = "Content-Type"
|
||
|
contentLengthHeader = "Content-Length"
|
||
|
contentEncodingHeader = "Content-Encoding"
|
||
|
acceptEncodingHeader = "Accept-Encoding"
|
||
|
)
|
||
|
|
||
|
var bufPool sync.Pool
|
||
|
|
||
|
func getBuf() *bytes.Buffer {
|
||
|
buf := bufPool.Get()
|
||
|
if buf == nil {
|
||
|
return &bytes.Buffer{}
|
||
|
}
|
||
|
return buf.(*bytes.Buffer)
|
||
|
}
|
||
|
|
||
|
func giveBuf(buf *bytes.Buffer) {
|
||
|
buf.Reset()
|
||
|
bufPool.Put(buf)
|
||
|
}
|
||
|
|
||
|
// Handler returns an HTTP handler for the prometheus.DefaultDeliverer. The
|
||
|
// Handler uses the default HandlerOpts, i.e. report the first error as an HTTP
|
||
|
// error, no error logging, and compression if requested by the client.
|
||
|
//
|
||
|
// If you want to create a Handler for the DefaultDeliverer with different
|
||
|
// HandlerOpts, create it with HandlerFor with prometheus.DefaultDeliverer and
|
||
|
// your desired HandlerOpts.
|
||
|
func Handler() http.Handler {
|
||
|
return HandlerFor(prometheus.DefaultDeliverer, HandlerOpts{})
|
||
|
}
|
||
|
|
||
|
// HandlerFor returns an http.Handler for the provided Deliverer. The behavior
|
||
|
// ef the Handler is defined by the provided HandlerOpts.
|
||
|
func HandlerFor(reg prometheus.Deliverer, opts HandlerOpts) http.Handler {
|
||
|
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
|
||
|
mfs, err := reg.Deliver()
|
||
|
if err != nil {
|
||
|
if opts.ErrorLog != nil {
|
||
|
opts.ErrorLog.Println("error collecting metrics:", err)
|
||
|
}
|
||
|
switch opts.ErrorHandling {
|
||
|
case PanicOnError:
|
||
|
panic(err)
|
||
|
case ContinueOnError:
|
||
|
if len(mfs) == 0 {
|
||
|
http.Error(w, "No metrics collected, last error:\n\n"+err.Error(), http.StatusInternalServerError)
|
||
|
return
|
||
|
}
|
||
|
case HTTPErrorOnError:
|
||
|
http.Error(w, "An error has occurred during metrics collection:\n\n"+err.Error(), http.StatusInternalServerError)
|
||
|
return
|
||
|
}
|
||
|
}
|
||
|
|
||
|
contentType := expfmt.Negotiate(req.Header)
|
||
|
buf := getBuf()
|
||
|
defer giveBuf(buf)
|
||
|
writer, encoding := decorateWriter(req, buf, opts.DisableCompression)
|
||
|
enc := expfmt.NewEncoder(writer, contentType)
|
||
|
var lastErr error
|
||
|
for _, mf := range mfs {
|
||
|
if err := enc.Encode(mf); err != nil {
|
||
|
lastErr = err
|
||
|
if opts.ErrorLog != nil {
|
||
|
opts.ErrorLog.Println("error encoding metric family:", err)
|
||
|
}
|
||
|
switch opts.ErrorHandling {
|
||
|
case PanicOnError:
|
||
|
panic(err)
|
||
|
case ContinueOnError:
|
||
|
// Handled later.
|
||
|
case HTTPErrorOnError:
|
||
|
http.Error(w, "An error has occurred during metrics encoding:\n\n"+err.Error(), http.StatusInternalServerError)
|
||
|
return
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if closer, ok := writer.(io.Closer); ok {
|
||
|
closer.Close()
|
||
|
}
|
||
|
if lastErr != nil && buf.Len() == 0 {
|
||
|
http.Error(w, "No metrics encoded, last error:\n\n"+err.Error(), http.StatusInternalServerError)
|
||
|
return
|
||
|
}
|
||
|
header := w.Header()
|
||
|
header.Set(contentTypeHeader, string(contentType))
|
||
|
header.Set(contentLengthHeader, fmt.Sprint(buf.Len()))
|
||
|
if encoding != "" {
|
||
|
header.Set(contentEncodingHeader, encoding)
|
||
|
}
|
||
|
w.Write(buf.Bytes())
|
||
|
// TODO(beorn7): Consider streaming serving of metrics.
|
||
|
})
|
||
|
}
|
||
|
|
||
|
// HandlerErrorHandling defines how a Handler serving metrics will handle
|
||
|
// errors.
|
||
|
type HandlerErrorHandling int
|
||
|
|
||
|
// These constants cause handlers serving metrics to behave as described if
|
||
|
// errors are encountered.
|
||
|
const (
|
||
|
// Serve an HTTP status code 500 upon the first error
|
||
|
// encountered. Report the error message in the body.
|
||
|
HTTPErrorOnError HandlerErrorHandling = iota
|
||
|
// Ignore errors and try to serve as many metrics as possible. However,
|
||
|
// if no metrics can be served, serve an HTTP status code 500 and the
|
||
|
// last error message in the body. Only use this in deliberate "best
|
||
|
// effort" metrics collection scenarios. It is recommended to at least
|
||
|
// log errors (by providing an ErrorLog in HandlerOpts) to not mask
|
||
|
// errors completely.
|
||
|
ContinueOnError
|
||
|
// Panic upon the first error encountered (useful for "crash only" apps).
|
||
|
PanicOnError
|
||
|
)
|
||
|
|
||
|
// Logger is the minimal interface HandlerOpts needs for logging. Note that
|
||
|
// log.Logger from the standard library implements this interface, and it is
|
||
|
// easy to implement by custom loggers, if they don't do so already anyway.
|
||
|
type Logger interface {
|
||
|
Println(v ...interface{})
|
||
|
}
|
||
|
|
||
|
// HandlerOpts specifies options how to serve metrics via an http.Handler. The
|
||
|
// zero value of HandlerOpts is a reasonable default.
|
||
|
type HandlerOpts struct {
|
||
|
// ErrorLog specifies an optional logger for errors collecting and
|
||
|
// serving metrics. If nil, errors are not logged at all.
|
||
|
ErrorLog Logger
|
||
|
// ErrorHandling defines how errors are handled. Note that errors are
|
||
|
// logged regardless of the configured ErrorHandling provided ErrorLog
|
||
|
// is not nil.
|
||
|
ErrorHandling HandlerErrorHandling
|
||
|
// If DisableCompression is true, the handler will never compress the
|
||
|
// response, even if requested by the client.
|
||
|
DisableCompression bool
|
||
|
}
|
||
|
|
||
|
// decorateWriter wraps a writer to handle gzip compression if requested. It
|
||
|
// returns the decorated writer and the appropriate "Content-Encoding" header
|
||
|
// (which is empty if no compression is enabled).
|
||
|
func decorateWriter(request *http.Request, writer io.Writer, compressionDisabled bool) (io.Writer, string) {
|
||
|
if compressionDisabled {
|
||
|
return writer, ""
|
||
|
}
|
||
|
header := request.Header.Get(acceptEncodingHeader)
|
||
|
parts := strings.Split(header, ",")
|
||
|
for _, part := range parts {
|
||
|
part := strings.TrimSpace(part)
|
||
|
if part == "gzip" || strings.HasPrefix(part, "gzip;") {
|
||
|
return gzip.NewWriter(writer), "gzip"
|
||
|
}
|
||
|
}
|
||
|
return writer, ""
|
||
|
}
|