2019-05-22 21:16:55 +00:00
package httpserver
import (
"bufio"
"context"
"crypto/tls"
2020-06-30 21:02:02 +00:00
"errors"
2019-05-24 09:18:40 +00:00
"flag"
2019-05-22 21:16:55 +00:00
"fmt"
"io"
2021-05-11 19:03:48 +00:00
"log"
2019-05-22 21:16:55 +00:00
"net"
"net/http"
"net/http/pprof"
2021-05-03 08:51:15 +00:00
"os"
2021-04-30 06:19:08 +00:00
"path"
2019-05-22 21:16:55 +00:00
"runtime"
"strconv"
"strings"
"sync"
2020-05-07 12:20:06 +00:00
"sync/atomic"
2019-05-22 21:16:55 +00:00
"time"
2020-09-03 19:22:26 +00:00
"github.com/VictoriaMetrics/VictoriaMetrics/lib/fasttime"
2019-05-22 21:16:55 +00:00
"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
"github.com/VictoriaMetrics/VictoriaMetrics/lib/netutil"
"github.com/VictoriaMetrics/metrics"
2020-01-17 21:57:18 +00:00
"github.com/klauspost/compress/gzip"
2020-09-08 16:54:41 +00:00
"github.com/valyala/fastrand"
2019-05-22 21:16:55 +00:00
)
var (
2020-08-07 07:56:50 +00:00
tlsEnable = flag . Bool ( "tls" , false , "Whether to enable TLS (aka HTTPS) for incoming requests. -tlsCertFile and -tlsKeyFile must be set if -tls is set" )
2021-04-12 09:28:04 +00:00
tlsCertFile = flag . String ( "tlsCertFile" , "" , "Path to file with TLS certificate. Used only if -tls is set. Prefer ECDSA certs instead of RSA certs as RSA certs are slower" )
2020-08-07 07:56:50 +00:00
tlsKeyFile = flag . String ( "tlsKeyFile" , "" , "Path to file with TLS key. Used only if -tls is set" )
2020-05-02 10:07:30 +00:00
pathPrefix = flag . String ( "http.pathPrefix" , "" , "An optional prefix to add to all the paths handled by http server. For example, if '-http.pathPrefix=/foo/bar' is set, " +
"then all the http requests will be handled on '/foo/bar/*' paths. This may be useful for proxied requests. " +
"See https://www.robustperception.io/using-external-urls-and-proxies-with-prometheus" )
2020-08-07 07:56:50 +00:00
2021-04-12 09:28:04 +00:00
disableResponseCompression = flag . Bool ( "http.disableResponseCompression" , false , "Disable compression of HTTP responses to save CPU resources. By default compression is enabled to save network bandwidth" )
maxGracefulShutdownDuration = flag . Duration ( "http.maxGracefulShutdownDuration" , 7 * time . Second , ` The maximum duration for a graceful shutdown of the HTTP server. A highly loaded server may require increased value for a graceful shutdown ` )
2021-05-18 13:24:43 +00:00
shutdownDelay = flag . Duration ( "http.shutdownDelay" , 0 , ` Optional delay before http server shutdown. During this delay, the server returns non-OK responses from /health page, so load balancers can route new requests to other servers ` )
2021-04-12 09:28:04 +00:00
idleConnTimeout = flag . Duration ( "http.idleConnTimeout" , time . Minute , "Timeout for incoming idle http connections" )
connTimeout = flag . Duration ( "http.connTimeout" , 2 * time . Minute , ` Incoming http connections are closed after the configured timeout. This may help to spread the incoming load among a cluster of services behind a load balancer. Please note that the real timeout may be bigger by up to 10% as a protection against the thundering herd problem ` )
2020-05-07 12:20:06 +00:00
)
2019-05-24 09:18:40 +00:00
2020-05-07 12:20:06 +00:00
var (
servers = make ( map [ string ] * server )
2019-05-22 21:16:55 +00:00
serversLock sync . Mutex
)
2020-05-07 12:20:06 +00:00
type server struct {
shutdownDelayDeadline int64
s * http . Server
}
2019-05-22 21:16:55 +00:00
// RequestHandler must serve the given request r and write response to w.
//
// RequestHandler must return true if the request has been served (successfully or not).
//
// RequestHandler must return false if it cannot serve the given request.
// In such cases the caller must serve the request.
type RequestHandler func ( w http . ResponseWriter , r * http . Request ) bool
// Serve starts an http server on the given addr with the given rh.
//
// By default all the responses are transparently compressed, since Google
// charges a lot for the egress traffic. The compression may be disabled
// by calling DisableResponseCompression before writing the first byte to w.
2019-05-24 09:18:40 +00:00
//
// The compression is also disabled if -http.disableResponseCompression flag is set.
2019-05-22 21:16:55 +00:00
func Serve ( addr string , rh RequestHandler ) {
2020-08-07 07:56:50 +00:00
scheme := "http"
if * tlsEnable {
scheme = "https"
}
logger . Infof ( "starting http server at %s://%s/" , scheme , addr )
logger . Infof ( "pprof handlers are exposed at %s://%s/debug/pprof/" , scheme , addr )
lnTmp , err := netutil . NewTCPListener ( scheme , addr )
2019-05-22 21:16:55 +00:00
if err != nil {
2020-08-07 07:56:50 +00:00
logger . Fatalf ( "cannot start http server at %s: %s" , addr , err )
}
ln := net . Listener ( lnTmp )
if * tlsEnable {
cert , err := tls . LoadX509KeyPair ( * tlsCertFile , * tlsKeyFile )
if err != nil {
logger . Fatalf ( "cannot load TLS cert from tlsCertFile=%q, tlsKeyFile=%q: %s" , * tlsCertFile , * tlsKeyFile , err )
}
cfg := & tls . Config {
2021-01-12 22:35:47 +00:00
Certificates : [ ] tls . Certificate { cert } ,
MinVersion : tls . VersionTLS12 ,
PreferServerCipherSuites : true ,
2020-08-07 07:56:50 +00:00
}
ln = tls . NewListener ( ln , cfg )
2019-05-22 21:16:55 +00:00
}
serveWithListener ( addr , ln , rh )
}
func serveWithListener ( addr string , ln net . Listener , rh RequestHandler ) {
2020-05-07 12:20:06 +00:00
var s server
s . s = & http . Server {
Handler : gzipHandler ( & s , rh ) ,
2019-05-22 21:16:55 +00:00
2020-05-07 11:10:40 +00:00
// Disable http/2, since it doesn't give any advantages for VictoriaMetrics services.
2019-05-22 21:16:55 +00:00
TLSNextProto : make ( map [ string ] func ( * http . Server , * tls . Conn , http . Handler ) ) ,
2020-05-07 11:10:40 +00:00
ReadHeaderTimeout : 5 * time . Second ,
2020-09-01 12:32:50 +00:00
IdleTimeout : * idleConnTimeout ,
2019-05-22 21:16:55 +00:00
2020-05-07 11:10:40 +00:00
// Do not set ReadTimeout and WriteTimeout here,
// since these timeouts must be controlled by request handlers.
2019-05-22 21:16:55 +00:00
ErrorLog : logger . StdErrorLogger ( ) ,
2020-09-03 19:22:26 +00:00
ConnContext : func ( ctx context . Context , c net . Conn ) context . Context {
2020-09-08 16:54:41 +00:00
timeoutSec := connTimeout . Seconds ( )
// Add a jitter for connection timeout in order to prevent Thundering herd problem
// when all the connections are established at the same time.
// See https://en.wikipedia.org/wiki/Thundering_herd_problem
jitterSec := fastrand . Uint32n ( uint32 ( timeoutSec / 10 ) )
deadline := fasttime . UnixTimestamp ( ) + uint64 ( timeoutSec ) + uint64 ( jitterSec )
return context . WithValue ( ctx , connDeadlineTimeKey , & deadline )
2020-09-03 19:22:26 +00:00
} ,
2019-05-22 21:16:55 +00:00
}
serversLock . Lock ( )
2020-05-07 12:20:06 +00:00
servers [ addr ] = & s
2019-05-22 21:16:55 +00:00
serversLock . Unlock ( )
2020-05-07 12:20:06 +00:00
if err := s . s . Serve ( ln ) ; err != nil {
2019-05-22 21:16:55 +00:00
if err == http . ErrServerClosed {
// The server gracefully closed.
return
}
logger . Panicf ( "FATAL: cannot serve http at %s: %s" , addr , err )
}
}
2020-09-03 19:22:26 +00:00
func whetherToCloseConn ( r * http . Request ) bool {
ctx := r . Context ( )
2020-09-08 16:54:41 +00:00
v := ctx . Value ( connDeadlineTimeKey )
deadline , ok := v . ( * uint64 )
return ok && fasttime . UnixTimestamp ( ) > * deadline
2020-09-03 19:22:26 +00:00
}
2020-09-08 16:54:41 +00:00
var connDeadlineTimeKey = interface { } ( "connDeadlineSecs" )
2020-09-03 19:22:26 +00:00
2019-05-22 21:16:55 +00:00
// Stop stops the http server on the given addr, which has been started
// via Serve func.
func Stop ( addr string ) error {
serversLock . Lock ( )
s := servers [ addr ]
delete ( servers , addr )
serversLock . Unlock ( )
if s == nil {
2021-05-20 15:27:10 +00:00
err := fmt . Errorf ( "BUG: there is no http server at %q" , addr )
logger . Panicf ( "%s" , err )
// The return is needed for golangci-lint: SA5011(related information): this check suggests that the pointer can be nil
return err
2019-05-22 21:16:55 +00:00
}
2020-05-07 12:20:06 +00:00
deadline := time . Now ( ) . Add ( * shutdownDelay ) . UnixNano ( )
atomic . StoreInt64 ( & s . shutdownDelayDeadline , deadline )
if * shutdownDelay > 0 {
// Sleep for a while until load balancer in front of the server
// notifies that "/health" endpoint returns non-OK responses.
// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/463 .
logger . Infof ( "Waiting for %.3fs before shutdown of http server %q, so load balancers could re-route requests to other servers" , shutdownDelay . Seconds ( ) , addr )
time . Sleep ( * shutdownDelay )
logger . Infof ( "Starting shutdown for http server %q" , addr )
}
ctx , cancel := context . WithTimeout ( context . Background ( ) , * maxGracefulShutdownDuration )
defer cancel ( )
if err := s . s . Shutdown ( ctx ) ; err != nil {
2020-04-29 22:36:56 +00:00
return fmt . Errorf ( "cannot gracefully shutdown http server at %q in %.3fs; " +
"probably, `-http.maxGracefulShutdownDuration` command-line flag value must be increased; error: %s" , addr , maxGracefulShutdownDuration . Seconds ( ) , err )
2019-05-22 21:16:55 +00:00
}
return nil
}
2020-05-07 12:20:06 +00:00
func gzipHandler ( s * server , rh RequestHandler ) http . HandlerFunc {
2020-04-01 15:14:17 +00:00
return func ( w http . ResponseWriter , r * http . Request ) {
2019-05-22 21:16:55 +00:00
w = maybeGzipResponseWriter ( w , r )
2020-05-07 12:20:06 +00:00
handlerWrapper ( s , w , r , rh )
2019-05-22 21:16:55 +00:00
if zrw , ok := w . ( * gzipResponseWriter ) ; ok {
if err := zrw . Close ( ) ; err != nil && ! isTrivialNetworkError ( err ) {
2020-04-15 17:50:12 +00:00
logger . Warnf ( "gzipResponseWriter.Close: %s" , err )
2019-05-22 21:16:55 +00:00
}
}
}
}
2019-11-22 22:19:44 +00:00
var metricsHandlerDuration = metrics . NewHistogram ( ` vm_http_request_duration_seconds { path="/metrics"} ` )
2020-09-03 19:22:26 +00:00
var connTimeoutClosedConns = metrics . NewCounter ( ` vm_http_conn_timeout_closed_conns_total ` )
2019-05-22 21:16:55 +00:00
2021-05-11 19:03:48 +00:00
var hostname = func ( ) string {
h , err := os . Hostname ( )
if err != nil {
// Cannot use logger.Errorf, since it isn't initialized yet.
// So use log.Printf instead.
log . Printf ( "ERROR: cannot determine hostname: %s" , err )
return "unknown"
}
return h
} ( )
2020-05-07 12:20:06 +00:00
func handlerWrapper ( s * server , w http . ResponseWriter , r * http . Request , rh RequestHandler ) {
2021-05-03 08:51:15 +00:00
// All the VictoriaMetrics code assumes that panic stops the process.
// Unfortunately, the standard net/http.Server recovers from panics in request handlers,
// so VictoriaMetrics state can become inconsistent after the recovered panic.
// The following recover() code works around this by explicitly stopping the process after logging the panic.
// See https://github.com/golang/go/issues/16542#issuecomment-246549902 for details.
defer func ( ) {
2021-06-11 09:50:22 +00:00
if err := recover ( ) ; err != nil {
2021-05-03 08:51:15 +00:00
buf := make ( [ ] byte , 1 << 20 )
n := runtime . Stack ( buf , false )
fmt . Fprintf ( os . Stderr , "panic: %v\n\n%s" , err , buf [ : n ] )
os . Exit ( 1 )
}
} ( )
2021-05-11 20:47:16 +00:00
w . Header ( ) . Add ( "X-Server-Hostname" , hostname )
2019-05-22 21:16:55 +00:00
requestsTotal . Inc ( )
2020-09-03 19:22:26 +00:00
if whetherToCloseConn ( r ) {
connTimeoutClosedConns . Inc ( )
w . Header ( ) . Set ( "Connection" , "close" )
}
2020-05-02 10:07:30 +00:00
path , err := getCanonicalPath ( r . URL . Path )
if err != nil {
2020-07-20 11:00:33 +00:00
Errorf ( w , r , "cannot get canonical path: %s" , err )
2020-05-02 10:07:30 +00:00
unsupportedRequestErrors . Inc ( )
return
}
r . URL . Path = path
2019-05-22 21:16:55 +00:00
switch r . URL . Path {
case "/health" :
2020-11-13 08:25:39 +00:00
w . Header ( ) . Set ( "Content-Type" , "text/plain; charset=utf-8" )
2020-05-07 12:20:06 +00:00
deadline := atomic . LoadInt64 ( & s . shutdownDelayDeadline )
if deadline <= 0 {
w . Write ( [ ] byte ( "OK" ) )
return
}
// Return non-OK response during grace period before shutting down the server.
// Load balancers must notify these responses and re-route new requests to other servers.
// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/463 .
d := time . Until ( time . Unix ( 0 , deadline ) )
if d < 0 {
d = 0
}
errMsg := fmt . Sprintf ( "The server is in delayed shutdown mode, which will end in %.3fs" , d . Seconds ( ) )
http . Error ( w , errMsg , http . StatusServiceUnavailable )
2019-05-22 21:16:55 +00:00
return
2019-12-04 17:15:49 +00:00
case "/ping" :
2021-09-13 14:04:28 +00:00
// This is needed for compatibility with InfluxDB agents.
2019-12-04 17:15:49 +00:00
// See https://docs.influxdata.com/influxdb/v1.7/tools/api/#ping-http-endpoint
status := http . StatusNoContent
if verbose := r . FormValue ( "verbose" ) ; verbose == "true" {
status = http . StatusOK
}
w . WriteHeader ( status )
return
2019-12-18 21:08:22 +00:00
case "/favicon.ico" :
faviconRequests . Inc ( )
w . WriteHeader ( http . StatusNoContent )
return
2019-05-22 21:16:55 +00:00
case "/metrics" :
metricsRequests . Inc ( )
2019-12-18 21:08:22 +00:00
startTime := time . Now ( )
2020-11-13 08:25:39 +00:00
w . Header ( ) . Set ( "Content-Type" , "text/plain; charset=utf-8" )
2020-08-07 07:56:50 +00:00
WritePrometheusMetrics ( w )
2019-05-22 21:16:55 +00:00
metricsHandlerDuration . UpdateDuration ( startTime )
return
default :
if strings . HasPrefix ( r . URL . Path , "/debug/pprof/" ) {
pprofRequests . Inc ( )
DisableResponseCompression ( w )
pprofHandler ( r . URL . Path [ len ( "/debug/pprof/" ) : ] , w , r )
return
}
if rh ( w , r ) {
return
}
2020-07-20 11:00:33 +00:00
Errorf ( w , r , "unsupported path requested: %q" , r . URL . Path )
2019-05-22 21:16:55 +00:00
unsupportedRequestErrors . Inc ( )
return
}
}
2020-05-02 10:07:30 +00:00
func getCanonicalPath ( path string ) ( string , error ) {
2020-12-14 11:36:48 +00:00
if len ( * pathPrefix ) == 0 || path == "/" {
2020-05-02 10:07:30 +00:00
return path , nil
}
2020-12-14 11:36:48 +00:00
if * pathPrefix == path {
return "/" , nil
}
2020-05-02 10:07:30 +00:00
prefix := * pathPrefix
if ! strings . HasSuffix ( prefix , "/" ) {
prefix = prefix + "/"
}
if ! strings . HasPrefix ( path , prefix ) {
return "" , fmt . Errorf ( "missing `-pathPrefix=%q` in the requested path: %q" , * pathPrefix , path )
}
path = path [ len ( prefix ) - 1 : ]
return path , nil
}
2019-05-22 21:16:55 +00:00
func maybeGzipResponseWriter ( w http . ResponseWriter , r * http . Request ) http . ResponseWriter {
2019-05-24 09:18:40 +00:00
if * disableResponseCompression {
return w
}
2020-10-17 10:32:34 +00:00
if r . Header . Get ( "Connection" ) == "Upgrade" {
return w
}
2019-05-22 21:16:55 +00:00
ae := r . Header . Get ( "Accept-Encoding" )
if ae == "" {
return w
}
ae = strings . ToLower ( ae )
n := strings . Index ( ae , "gzip" )
if n < 0 {
2020-05-22 13:44:09 +00:00
// Do not apply gzip encoding to the response.
2019-05-22 21:16:55 +00:00
return w
}
2020-05-22 13:44:09 +00:00
// Apply gzip encoding to the response.
2019-05-22 21:16:55 +00:00
zw := getGzipWriter ( w )
bw := getBufioWriter ( zw )
zrw := & gzipResponseWriter {
2021-02-28 17:21:30 +00:00
rw : w ,
zw : zw ,
bw : bw ,
2019-05-22 21:16:55 +00:00
}
return zrw
}
// DisableResponseCompression disables response compression on w.
//
// The function must be called before the first w.Write* call.
func DisableResponseCompression ( w http . ResponseWriter ) {
2020-05-22 13:44:09 +00:00
zrw , ok := w . ( * gzipResponseWriter )
if ! ok {
return
}
if zrw . firstWriteDone {
logger . Panicf ( "BUG: DisableResponseCompression must be called before sending the response" )
}
zrw . disableCompression = true
2019-05-22 21:16:55 +00:00
}
// EnableCORS enables https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
// on the response.
func EnableCORS ( w http . ResponseWriter , _ * http . Request ) {
w . Header ( ) . Set ( "Access-Control-Allow-Origin" , "*" )
}
func getGzipWriter ( w io . Writer ) * gzip . Writer {
v := gzipWriterPool . Get ( )
if v == nil {
zw , err := gzip . NewWriterLevel ( w , 1 )
if err != nil {
logger . Panicf ( "BUG: cannot create gzip writer: %s" , err )
}
return zw
}
zw := v . ( * gzip . Writer )
zw . Reset ( w )
return zw
}
func putGzipWriter ( zw * gzip . Writer ) {
gzipWriterPool . Put ( zw )
}
var gzipWriterPool sync . Pool
type gzipResponseWriter struct {
2021-02-28 17:21:30 +00:00
rw http . ResponseWriter
2019-05-22 21:16:55 +00:00
zw * gzip . Writer
bw * bufio . Writer
statusCode int
firstWriteDone bool
disableCompression bool
}
2021-02-28 17:21:30 +00:00
// Implements http.ResponseWriter.Header method.
func ( zrw * gzipResponseWriter ) Header ( ) http . Header {
return zrw . rw . Header ( )
}
// Implements http.ResponseWriter.Write method.
2019-05-22 21:16:55 +00:00
func ( zrw * gzipResponseWriter ) Write ( p [ ] byte ) ( int , error ) {
if ! zrw . firstWriteDone {
h := zrw . Header ( )
2020-05-24 19:12:20 +00:00
if zrw . statusCode == http . StatusNoContent {
zrw . disableCompression = true
}
2020-05-22 13:44:09 +00:00
if h . Get ( "Content-Encoding" ) != "" {
2019-05-22 21:16:55 +00:00
zrw . disableCompression = true
2020-05-22 13:44:09 +00:00
}
if ! zrw . disableCompression {
h . Set ( "Content-Encoding" , "gzip" )
2020-05-24 19:12:20 +00:00
h . Del ( "Content-Length" )
2020-05-22 13:44:09 +00:00
if h . Get ( "Content-Type" ) == "" {
// Disable auto-detection of content-type, since it
// is incorrectly detected after the compression.
2020-11-13 08:25:39 +00:00
h . Set ( "Content-Type" , "text/html; charset=utf-8" )
2020-05-22 13:44:09 +00:00
}
2019-05-22 21:16:55 +00:00
}
2020-05-24 20:55:28 +00:00
zrw . writeHeader ( )
2019-05-22 21:16:55 +00:00
zrw . firstWriteDone = true
}
if zrw . disableCompression {
2021-02-28 17:21:30 +00:00
return zrw . rw . Write ( p )
2019-05-22 21:16:55 +00:00
}
return zrw . bw . Write ( p )
}
2021-02-28 17:21:30 +00:00
// Implements http.ResponseWriter.WriteHeader method.
2019-05-22 21:16:55 +00:00
func ( zrw * gzipResponseWriter ) WriteHeader ( statusCode int ) {
zrw . statusCode = statusCode
}
2020-05-24 20:55:28 +00:00
func ( zrw * gzipResponseWriter ) writeHeader ( ) {
if zrw . statusCode == 0 {
zrw . statusCode = http . StatusOK
}
2021-02-28 17:21:30 +00:00
zrw . rw . WriteHeader ( zrw . statusCode )
2020-05-24 20:55:28 +00:00
}
2019-05-22 21:16:55 +00:00
// Implements http.Flusher
func ( zrw * gzipResponseWriter ) Flush ( ) {
2021-02-28 17:21:30 +00:00
if ! zrw . firstWriteDone {
2021-02-28 22:34:10 +00:00
_ , _ = zrw . Write ( nil )
2021-02-28 17:21:30 +00:00
}
2020-06-05 18:37:10 +00:00
if ! zrw . disableCompression {
if err := zrw . bw . Flush ( ) ; err != nil && ! isTrivialNetworkError ( err ) {
logger . Warnf ( "gzipResponseWriter.Flush (buffer): %s" , err )
}
if err := zrw . zw . Flush ( ) ; err != nil && ! isTrivialNetworkError ( err ) {
logger . Warnf ( "gzipResponseWriter.Flush (gzip): %s" , err )
}
2019-05-22 21:16:55 +00:00
}
2021-02-28 17:21:30 +00:00
if fw , ok := zrw . rw . ( http . Flusher ) ; ok {
2019-05-22 21:16:55 +00:00
fw . Flush ( )
}
}
func ( zrw * gzipResponseWriter ) Close ( ) error {
if ! zrw . firstWriteDone {
2021-02-28 22:34:10 +00:00
_ , _ = zrw . Write ( nil )
2019-05-22 21:16:55 +00:00
}
zrw . Flush ( )
2020-06-05 18:37:10 +00:00
var err error
if ! zrw . disableCompression {
err = zrw . zw . Close ( )
}
2019-05-22 21:16:55 +00:00
putGzipWriter ( zrw . zw )
zrw . zw = nil
putBufioWriter ( zrw . bw )
zrw . bw = nil
return err
}
func getBufioWriter ( w io . Writer ) * bufio . Writer {
v := bufioWriterPool . Get ( )
if v == nil {
return bufio . NewWriterSize ( w , 16 * 1024 )
}
bw := v . ( * bufio . Writer )
bw . Reset ( w )
return bw
}
func putBufioWriter ( bw * bufio . Writer ) {
bufioWriterPool . Put ( bw )
}
var bufioWriterPool sync . Pool
func pprofHandler ( profileName string , w http . ResponseWriter , r * http . Request ) {
// This switch has been stolen from init func at https://golang.org/src/net/http/pprof/pprof.go
switch profileName {
case "cmdline" :
pprofCmdlineRequests . Inc ( )
pprof . Cmdline ( w , r )
case "profile" :
pprofProfileRequests . Inc ( )
pprof . Profile ( w , r )
case "symbol" :
pprofSymbolRequests . Inc ( )
pprof . Symbol ( w , r )
case "trace" :
pprofTraceRequests . Inc ( )
pprof . Trace ( w , r )
case "mutex" :
pprofMutexRequests . Inc ( )
seconds , _ := strconv . Atoi ( r . FormValue ( "seconds" ) )
if seconds <= 0 {
seconds = 10
}
prev := runtime . SetMutexProfileFraction ( 10 )
time . Sleep ( time . Duration ( seconds ) * time . Second )
pprof . Index ( w , r )
runtime . SetMutexProfileFraction ( prev )
default :
pprofDefaultRequests . Inc ( )
pprof . Index ( w , r )
}
}
var (
metricsRequests = metrics . NewCounter ( ` vm_http_requests_total { path="/metrics"} ` )
pprofRequests = metrics . NewCounter ( ` vm_http_requests_total { path="/debug/pprof/"} ` )
pprofCmdlineRequests = metrics . NewCounter ( ` vm_http_requests_total { path="/debug/pprof/cmdline"} ` )
pprofProfileRequests = metrics . NewCounter ( ` vm_http_requests_total { path="/debug/pprof/profile"} ` )
pprofSymbolRequests = metrics . NewCounter ( ` vm_http_requests_total { path="/debug/pprof/symbol"} ` )
pprofTraceRequests = metrics . NewCounter ( ` vm_http_requests_total { path="/debug/pprof/trace"} ` )
pprofMutexRequests = metrics . NewCounter ( ` vm_http_requests_total { path="/debug/pprof/mutex"} ` )
pprofDefaultRequests = metrics . NewCounter ( ` vm_http_requests_total { path="/debug/pprof/default"} ` )
faviconRequests = metrics . NewCounter ( ` vm_http_requests_total { path="/favicon.ico"} ` )
unsupportedRequestErrors = metrics . NewCounter ( ` vm_http_request_errors_total { path="*", reason="unsupported"} ` )
requestsTotal = metrics . NewCounter ( ` vm_http_requests_all_total ` )
)
2020-07-31 15:00:21 +00:00
// GetQuotedRemoteAddr returns quoted remote address.
func GetQuotedRemoteAddr ( r * http . Request ) string {
2020-07-29 10:12:15 +00:00
remoteAddr := strconv . Quote ( r . RemoteAddr ) // quote remoteAddr and X-Forwarded-For, since they may contain untrusted input
if addr := r . Header . Get ( "X-Forwarded-For" ) ; addr != "" {
remoteAddr += ", X-Forwarded-For: " + strconv . Quote ( addr )
}
2020-07-31 15:00:21 +00:00
return remoteAddr
}
// Errorf writes formatted error message to w and to logger.
func Errorf ( w http . ResponseWriter , r * http . Request , format string , args ... interface { } ) {
errStr := fmt . Sprintf ( format , args ... )
remoteAddr := GetQuotedRemoteAddr ( r )
2021-07-07 09:59:03 +00:00
requestURI := GetRequestURI ( r )
errStr = fmt . Sprintf ( "remoteAddr: %s; requestURI: %s; %s" , remoteAddr , requestURI , errStr )
2020-04-15 17:50:12 +00:00
logger . WarnfSkipframes ( 1 , "%s" , errStr )
2019-08-23 06:46:45 +00:00
// Extract statusCode from args
statusCode := http . StatusBadRequest
2020-06-30 21:02:02 +00:00
var esc * ErrorWithStatusCode
2019-08-23 06:46:45 +00:00
for _ , arg := range args {
2020-06-30 21:02:02 +00:00
if err , ok := arg . ( error ) ; ok && errors . As ( err , & esc ) {
2019-08-23 06:46:45 +00:00
statusCode = esc . StatusCode
break
}
}
http . Error ( w , errStr , statusCode )
}
// ErrorWithStatusCode is error with HTTP status code.
//
// The given StatusCode is sent to client when the error is passed to Errorf.
type ErrorWithStatusCode struct {
Err error
StatusCode int
}
2020-06-30 21:53:43 +00:00
// Unwrap returns e.Err.
//
// This is used by standard errors package. See https://golang.org/pkg/errors
func ( e * ErrorWithStatusCode ) Unwrap ( ) error {
return e . Err
}
2019-08-23 06:46:45 +00:00
// Error implements error interface.
func ( e * ErrorWithStatusCode ) Error ( ) string {
return e . Err . Error ( )
2019-05-22 21:16:55 +00:00
}
func isTrivialNetworkError ( err error ) bool {
s := err . Error ( )
if strings . Contains ( s , "broken pipe" ) || strings . Contains ( s , "reset by peer" ) {
return true
}
return false
}
2020-08-07 07:56:50 +00:00
// IsTLS indicates is tls enabled or not
func IsTLS ( ) bool {
return * tlsEnable
}
2020-12-14 11:36:48 +00:00
// GetPathPrefix - returns http server path prefix.
func GetPathPrefix ( ) string {
return * pathPrefix
}
2021-04-30 06:19:08 +00:00
// WriteAPIHelp writes pathList to w in HTML format.
func WriteAPIHelp ( w io . Writer , pathList [ ] [ 2 ] string ) {
for _ , p := range pathList {
p , doc := p [ 0 ] , p [ 1 ]
p = path . Join ( * pathPrefix , p )
fmt . Fprintf ( w , "<a href=%q>%s</a> - %s<br/>" , p , p , doc )
}
}
2021-07-07 09:59:03 +00:00
// GetRequestURI returns requestURI for r.
func GetRequestURI ( r * http . Request ) string {
requestURI := r . RequestURI
if r . Method != "POST" {
return requestURI
}
_ = r . ParseForm ( )
queryArgs := r . PostForm . Encode ( )
if len ( queryArgs ) == 0 {
return requestURI
}
delimiter := "?"
if strings . Contains ( requestURI , delimiter ) {
delimiter = "&"
}
return requestURI + delimiter + queryArgs
}