func initializeMetrics(origin, destination string) (*metricbatcher.MetricBatcher, error) {
err := setupDefaultEmitter(origin, destination)
if err != nil {
// Legacy holdover. We would prefer to panic, rather than just throwing our metrics
// away and pretending we're running fine, but for now, we just don't want to break
// anything.
dropsonde.DefaultEmitter = &dropsonde.NullEventEmitter{}
}
// Copied from dropsonde.initialize(), since we stopped using dropsonde.Initialize
// but needed it to continue operating the same.
sender := metric_sender.NewMetricSender(dropsonde.DefaultEmitter)
batcher := metricbatcher.New(sender, defaultBatchInterval)
metrics.Initialize(sender, batcher)
logs.Initialize(log_sender.NewLogSender(dropsonde.DefaultEmitter, gosteno.NewLogger("dropsonde/logs")))
envelopes.Initialize(envelope_sender.NewEnvelopeSender(dropsonde.DefaultEmitter))
go runtime_stats.NewRuntimeStats(dropsonde.DefaultEmitter, statsInterval).Run(nil)
http.DefaultTransport = dropsonde.InstrumentedRoundTripper(http.DefaultTransport)
return batcher, err
}
func (p *proxy) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
startedAt := time.Now()
accessLog := access_log.AccessLogRecord{
Request: request,
StartedAt: startedAt,
ExtraHeadersToLog: p.ExtraHeadersToLog,
}
requestBodyCounter := &countingReadCloser{delegate: request.Body}
request.Body = requestBodyCounter
proxyWriter := NewProxyResponseWriter(responseWriter)
handler := NewRequestHandler(request, proxyWriter, p.reporter, &accessLog)
defer func() {
accessLog.RequestBytesReceived = requestBodyCounter.count
p.accessLogger.Log(accessLog)
}()
if !isProtocolSupported(request) {
handler.HandleUnsupportedProtocol()
return
}
if isLoadBalancerHeartbeat(request) {
handler.HandleHeartbeat()
return
}
routePool := p.lookup(request)
if routePool == nil {
p.reporter.CaptureBadRequest(request)
handler.HandleMissingRoute()
return
}
stickyEndpointId := p.getStickySession(request)
iter := &wrappedIterator{
nested: routePool.Endpoints(stickyEndpointId),
afterNext: func(endpoint *route.Endpoint) {
if endpoint != nil {
handler.Logger().Set("RouteEndpoint", endpoint.ToLogData())
accessLog.RouteEndpoint = endpoint
p.reporter.CaptureRoutingRequest(endpoint, request)
}
},
}
if isTcpUpgrade(request) {
handler.HandleTcpRequest(iter)
accessLog.FinishedAt = time.Now()
return
}
if isWebSocketUpgrade(request) {
handler.HandleWebSocketRequest(iter)
accessLog.FinishedAt = time.Now()
return
}
backend := true
routeServiceUrl := routePool.RouteServiceUrl()
// Attempted to use a route service when it is not supported
if routeServiceUrl != "" && !p.routeServiceConfig.RouteServiceEnabled() {
handler.HandleUnsupportedRouteService()
return
}
var routeServiceArgs route_service.RouteServiceArgs
if routeServiceUrl != "" {
rsSignature := request.Header.Get(route_service.RouteServiceSignature)
forwardedUrlRaw := "http" + "://" + request.Host + request.RequestURI
if hasBeenToRouteService(routeServiceUrl, rsSignature) {
// A request from a route service destined for a backend instances
routeServiceArgs.UrlString = routeServiceUrl
err := p.routeServiceConfig.ValidateSignature(&request.Header, forwardedUrlRaw)
if err != nil {
handler.HandleBadSignature(err)
return
}
} else {
var err error
// should not hardcode http, will be addressed by #100982038
routeServiceArgs, err = buildRouteServiceArgs(p.routeServiceConfig, routeServiceUrl, forwardedUrlRaw)
backend = false
if err != nil {
handler.HandleRouteServiceFailure(err)
return
}
}
}
after := func(rsp *http.Response, endpoint *route.Endpoint, err error) {
accessLog.FirstByteAt = time.Now()
if rsp != nil {
accessLog.StatusCode = rsp.StatusCode
}
if p.traceKey != "" && request.Header.Get(router_http.VcapTraceHeader) == p.traceKey {
setTraceHeaders(responseWriter, p.ip, endpoint.CanonicalAddr())
}
latency := time.Since(startedAt)
p.reporter.CaptureRoutingResponse(endpoint, rsp, startedAt, latency)
if err != nil {
p.reporter.CaptureBadGateway(request)
handler.HandleBadGateway(err)
return
}
if endpoint.PrivateInstanceId != "" {
setupStickySession(responseWriter, rsp, endpoint, stickyEndpointId, p.secureCookies, routePool.ContextPath())
}
}
roundTripper := NewProxyRoundTripper(backend,
dropsonde.InstrumentedRoundTripper(p.transport), iter, handler, after)
newReverseProxy(roundTripper, request, routeServiceArgs, p.routeServiceConfig).ServeHTTP(proxyWriter, request)
accessLog.FinishedAt = time.Now()
accessLog.BodyBytesSent = proxyWriter.Size()
}
func (p *proxy) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
startedAt := time.Now()
accessLog := access_log.AccessLogRecord{
Request: request,
StartedAt: startedAt,
}
requestBodyCounter := &countingReadCloser{delegate: request.Body}
request.Body = requestBodyCounter
handler := NewRequestHandler(request, responseWriter, p.reporter, &accessLog)
defer func() {
accessLog.RequestBytesReceived = requestBodyCounter.count
p.accessLogger.Log(accessLog)
}()
if !isProtocolSupported(request) {
handler.HandleUnsupportedProtocol()
return
}
if isLoadBalancerHeartbeat(request) {
handler.HandleHeartbeat()
return
}
routePool := p.lookup(request)
if routePool == nil {
p.reporter.CaptureBadRequest(request)
handler.HandleMissingRoute()
return
}
stickyEndpointId := p.getStickySession(request)
iter := &wrappedIterator{
nested: routePool.Endpoints(stickyEndpointId),
afterNext: func(endpoint *route.Endpoint) {
if endpoint != nil {
handler.logger.Set("RouteEndpoint", endpoint.ToLogData())
accessLog.RouteEndpoint = endpoint
p.reporter.CaptureRoutingRequest(endpoint, request)
}
},
}
if isTcpUpgrade(request) {
handler.HandleTcpRequest(iter)
return
}
if isWebSocketUpgrade(request) {
handler.HandleWebSocketRequest(iter)
return
}
proxyWriter := newProxyResponseWriter(responseWriter)
roundTripper := &proxyRoundTripper{
transport: dropsonde.InstrumentedRoundTripper(p.transport),
iter: iter,
handler: &handler,
routeServiceTimeout: p.routeServiceTimeout,
after: func(rsp *http.Response, endpoint *route.Endpoint, err error) {
accessLog.FirstByteAt = time.Now()
if rsp != nil {
accessLog.StatusCode = rsp.StatusCode
}
if p.traceKey != "" && request.Header.Get(router_http.VcapTraceHeader) == p.traceKey {
setTraceHeaders(responseWriter, p.ip, endpoint.CanonicalAddr())
}
latency := time.Since(startedAt)
p.reporter.CaptureRoutingResponse(endpoint, rsp, startedAt, latency)
if err != nil {
p.reporter.CaptureBadGateway(request)
handler.HandleBadGateway(err)
proxyWriter.Done()
return
}
if endpoint.PrivateInstanceId != "" {
setupStickySession(responseWriter, rsp, endpoint, stickyEndpointId, p.secureCookies, routePool.ContextPath())
}
},
}
p.newReverseProxy(roundTripper, request).ServeHTTP(proxyWriter, request)
accessLog.FinishedAt = time.Now()
accessLog.BodyBytesSent = proxyWriter.Size()
}
}
var _ = Describe("InstrumentedRoundTripper", func() {
var fakeRoundTripper *FakeRoundTripper
var rt http.RoundTripper
var req *http.Request
var fakeEmitter *fake.FakeEventEmitter
var origin = "testRoundtripper/42"
BeforeEach(func() {
var err error
fakeEmitter = fake.NewFakeEventEmitter(origin)
fakeRoundTripper = new(FakeRoundTripper)
rt = dropsonde.InstrumentedRoundTripper(fakeRoundTripper, fakeEmitter)
req, err = http.NewRequest("GET", "http://foo.example.com/", nil)
Expect(err).ToNot(HaveOccurred())
req.RemoteAddr = "127.0.0.1"
req.Header.Set("User-Agent", "our-testing-client")
})
Describe("request ID", func() {
It("should generate a new request ID", func() {
rt.RoundTrip(req)
Expect(req.Header.Get("X-CF-RequestID")).ToNot(BeEmpty())
})
Context("if request ID can't be generated", func() {
func (p *proxy) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
proxyWriter := responseWriter.(utils.ProxyResponseWriter)
alr := proxyWriter.Context().Value("AccessLogRecord")
if alr == nil {
p.logger.Error("AccessLogRecord not set on context", errors.New("failed-to-access-LogRecord"))
}
accessLog := alr.(*schema.AccessLogRecord)
handler := handler.NewRequestHandler(request, proxyWriter, p.reporter, accessLog, p.logger)
if !isProtocolSupported(request) {
handler.HandleUnsupportedProtocol()
return
}
routePool := p.lookup(request)
if routePool == nil {
handler.HandleMissingRoute()
return
}
stickyEndpointId := p.getStickySession(request)
iter := &wrappedIterator{
nested: routePool.Endpoints(p.defaultLoadBalance, stickyEndpointId),
afterNext: func(endpoint *route.Endpoint) {
if endpoint != nil {
accessLog.RouteEndpoint = endpoint
p.reporter.CaptureRoutingRequest(endpoint, request)
}
},
}
if isTcpUpgrade(request) {
handler.HandleTcpRequest(iter)
return
}
if isWebSocketUpgrade(request) {
handler.HandleWebSocketRequest(iter)
return
}
backend := true
routeServiceUrl := routePool.RouteServiceUrl()
// Attempted to use a route service when it is not supported
if routeServiceUrl != "" && !p.routeServiceConfig.RouteServiceEnabled() {
handler.HandleUnsupportedRouteService()
return
}
var routeServiceArgs routeservice.RouteServiceRequest
if routeServiceUrl != "" {
rsSignature := request.Header.Get(routeservice.RouteServiceSignature)
var recommendedScheme string
if p.routeServiceRecommendHttps {
recommendedScheme = "https"
} else {
recommendedScheme = "http"
}
forwardedUrlRaw := recommendedScheme + "://" + hostWithoutPort(request) + request.RequestURI
if hasBeenToRouteService(routeServiceUrl, rsSignature) {
// A request from a route service destined for a backend instances
routeServiceArgs.URLString = routeServiceUrl
err := p.routeServiceConfig.ValidateSignature(&request.Header, forwardedUrlRaw)
if err != nil {
handler.HandleBadSignature(err)
return
}
} else {
var err error
// should not hardcode http, will be addressed by #100982038
routeServiceArgs, err = p.routeServiceConfig.Request(routeServiceUrl, forwardedUrlRaw)
backend = false
if err != nil {
handler.HandleRouteServiceFailure(err)
return
}
}
}
after := func(rsp *http.Response, endpoint *route.Endpoint, err error) {
if endpoint == nil {
handler.HandleBadGateway(err, request)
return
}
accessLog.FirstByteAt = time.Now()
if rsp != nil {
accessLog.StatusCode = rsp.StatusCode
}
if p.traceKey != "" && endpoint != nil && request.Header.Get(router_http.VcapTraceHeader) == p.traceKey {
router_http.SetTraceHeaders(responseWriter, p.ip, endpoint.CanonicalAddr())
}
latency := time.Since(accessLog.StartedAt)
if backend {
p.reporter.CaptureRoutingResponse(endpoint, rsp, accessLog.StartedAt, latency)
} else {
p.reporter.CaptureRouteServiceResponse(endpoint, rsp, accessLog.StartedAt, latency)
}
if err != nil {
handler.HandleBadGateway(err, request)
return
}
if endpoint.PrivateInstanceId != "" {
setupStickySession(responseWriter, rsp, endpoint, stickyEndpointId, p.secureCookies, routePool.ContextPath())
}
// if Content-Type not in response, nil out to suppress Go's auto-detect
if _, ok := rsp.Header["Content-Type"]; !ok {
responseWriter.Header()["Content-Type"] = nil
}
}
roundTripper := round_tripper.NewProxyRoundTripper(backend,
dropsonde.InstrumentedRoundTripper(p.transport), iter, handler.Logger(), after)
newReverseProxy(roundTripper, request, routeServiceArgs, p.routeServiceConfig, p.forceForwardedProtoHttps).ServeHTTP(proxyWriter, request)
}
// InstrumentedRoundTripper returns a RoundTripper pre-configured to emit
// HTTP client request metrics to autowire's Emitter.
func InstrumentedRoundTripper(roundTripper http.RoundTripper) http.RoundTripper {
return dropsonde.InstrumentedRoundTripper(roundTripper, autowiredEmitter)
}