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) }