private void SetOcelotRequestId(HttpContext context) { // if get request ID is set on upstream request then retrieve it var key = DownstreamRoute.ReRoute.RequestIdKey ?? DefaultRequestIdKey.Value; StringValues upstreamRequestIds; if (context.Request.Headers.TryGetValue(key, out upstreamRequestIds)) { //set the traceidentifier context.TraceIdentifier = upstreamRequestIds.First(); //check if we have previous id var previousRequestId = _requestScopedDataRepository.Get <string>("RequestId"); if (!previousRequestId.IsError && !string.IsNullOrEmpty(previousRequestId.Data)) { //we have a previous request id lets store it and update request id _requestScopedDataRepository.Add <string>("PreviousRequestId", previousRequestId.Data); _requestScopedDataRepository.Update <string>("RequestId", context.TraceIdentifier); } else { //else just add request id _requestScopedDataRepository.Add <string>("RequestId", context.TraceIdentifier); } } // set request ID on downstream request, if required var requestId = new RequestId(DownstreamRoute?.ReRoute?.RequestIdKey, context.TraceIdentifier); if (ShouldAddRequestId(requestId, DownstreamRequest.Headers)) { AddRequestIdHeader(requestId, DownstreamRequest); } }
private void SetOcelotRequestId(DownstreamContext context) { var key = context.DownstreamReRoute.RequestIdKey ?? DefaultRequestIdKey.Value; if (context.HttpContext.Request.Headers.TryGetValue(key, out var upstreamRequestIds)) { context.HttpContext.TraceIdentifier = upstreamRequestIds.First(); var previousRequestId = _requestScopedDataRepository.Get <string>("RequestId"); if (!previousRequestId.IsError && !string.IsNullOrEmpty(previousRequestId.Data) && previousRequestId.Data != context.HttpContext.TraceIdentifier) { _requestScopedDataRepository.Add("PreviousRequestId", previousRequestId.Data); _requestScopedDataRepository.Update("RequestId", context.HttpContext.TraceIdentifier); } else { _requestScopedDataRepository.Add("RequestId", context.HttpContext.TraceIdentifier); } } var requestId = new RequestId(context.DownstreamReRoute.RequestIdKey, context.HttpContext.TraceIdentifier); if (ShouldAddRequestId(requestId, context.DownstreamRequest.Headers)) { AddRequestIdHeader(requestId, context.DownstreamRequest); } }
private async Task TrySetGlobalRequestId(DownstreamContext context) { //try and get the global request id and set it for logs... //should this basically be immutable per request...i guess it should! //first thing is get config var configuration = await _provider.Get(); //if error throw to catch below.. if (configuration.IsError) { throw new Exception($"{MiddlewareName} setting pipeline errors. IOcelotConfigurationProvider returned {configuration.Errors.ToErrorString()}"); } //else set the request id? var key = configuration.Data.RequestId; StringValues upstreamRequestIds; if (!string.IsNullOrEmpty(key) && context.HttpContext.Request.Headers.TryGetValue(key, out upstreamRequestIds)) { //todo fix looking in both places context.HttpContext.TraceIdentifier = upstreamRequestIds.First(); _repo.Add <string>("RequestId", context.HttpContext.TraceIdentifier); } }
private void TrySetGlobalRequestId(DownstreamContext context, IInternalConfiguration configuration) { var key = configuration.RequestId; if (!string.IsNullOrEmpty(key) && context.HttpContext.Request.Headers.TryGetValue(key, out var upstreamRequestIds)) { context.HttpContext.TraceIdentifier = upstreamRequestIds.First(); } _repo.Add("RequestId", context.HttpContext.TraceIdentifier); }
private void SetOcelotRequestId(HttpContext context) { var key = DefaultRequestIdKey.Value; if (DownstreamRoute.ReRoute.RequestIdKey != null) { key = DownstreamRoute.ReRoute.RequestIdKey; } StringValues requestId; if (context.Request.Headers.TryGetValue(key, out requestId)) { _requestScopedDataRepository.Add("RequestId", requestId.First()); context.TraceIdentifier = requestId; } }
public async Task Invoke(HttpContext context) { ErrorResult errorInfo = null; var isException = false; try { await _next(context); } catch (BucketException ex) { var newMsg = _errorCodeStore.StringGet(ex.ErrorCode); if (string.IsNullOrWhiteSpace(newMsg)) { newMsg = ex.ErrorMessage; } errorInfo = new ErrorResult(ex.ErrorCode, newMsg); } catch (Exception ex) { errorInfo = new ErrorResult("-1", "系统开小差了,请稍后再试"); isException = true; _logger.LogError(ex, $"全局异常捕获,状态码:{ context?.Response?.StatusCode},Url:{context?.Request?.GetDisplayUrl()}"); } finally { if (errorInfo != null) { var Message = JsonConvert.SerializeObject(errorInfo); var trace = _requestScopedDataRepository.Get <TraceLogs>(TracerKeys.TraceStoreCacheKey); if (trace != null) { trace.Response = Message; trace.IsSuccess = true; trace.IsException = isException; trace.Code = errorInfo.ErrorCode; _requestScopedDataRepository.Add(TracerKeys.TraceStoreCacheKey, trace); } await HandleExceptionAsync(context, Message); } } }
private void TrySetGlobalRequestId(DownstreamContext context) { //try and get the global request id and set it for logs... //should this basically be immutable per request...i guess it should! //first thing is get config var configuration = _configRepo.Get(); if (configuration.IsError) { throw new Exception($"{MiddlewareName} setting pipeline errors. IOcelotConfigurationProvider returned {configuration.Errors.ToErrorString()}"); } var key = configuration.Data.RequestId; if (!string.IsNullOrEmpty(key) && context.HttpContext.Request.Headers.TryGetValue(key, out var upstreamRequestIds)) { context.HttpContext.TraceIdentifier = upstreamRequestIds.First(); } _repo.Add("RequestId", context.HttpContext.TraceIdentifier); }
protected virtual async Task <HttpResponseMessage> TracingSendAsync( ISpan span, HttpRequestMessage request, CancellationToken cancellationToken) { IEnumerable <string> traceIdVals = null; if (request.Headers.TryGetValues(prefix_spanId, out traceIdVals)) { request.Headers.Remove(prefix_spanId); request.Headers.TryAddWithoutValidation(prefix_spanId, span.SpanContext.SpanId); } _repo.Add("TraceId", span.SpanContext.TraceId); span.Tags.Client().Component("HttpClient") .HttpMethod(request.Method.Method) .HttpUrl(request.RequestUri.OriginalString) .HttpHost(request.RequestUri.Host) .HttpPath(request.RequestUri.PathAndQuery) .PeerAddress(request.RequestUri.OriginalString) .PeerHostName(request.RequestUri.Host) .PeerPort(request.RequestUri.Port); _tracer.Tracer.Inject(span.SpanContext, request.Headers, (c, k, v) => { if (!c.Contains(k)) { c.Add(k, v); } }); span.Log(LogField.CreateNew().ClientSend()); var responseMessage = await base.SendAsync(request, cancellationToken); span.Log(LogField.CreateNew().ClientReceive()); return(responseMessage); }
public async Task Invoke(HttpContext context) { var trace = new TraceLogs() { ApiUri = context?.Request?.GetDisplayUrl(), StartTime = DateTime.Now, ContextType = context?.Request?.ContentType }; _tracer.AddHeadersToTracer(context, trace); _requestScopedDataRepository.Add(TracerKeys.TraceStoreCacheKey, trace); await _next(context); trace = _requestScopedDataRepository.Get <TraceLogs>(TracerKeys.TraceStoreCacheKey); if (trace != null) { trace.EndTime = DateTime.Now; trace.TimeLength = Math.Round((trace.EndTime - trace.StartTime).TotalMilliseconds, 4); _requestScopedDataRepository.Update(TracerKeys.TraceStoreCacheKey, trace); await _tracer.PublishAsync(trace); } }
public void SetHostAndPortForThisRequest(HostAndPort hostAndPort) { _requestScopedDataRepository.Add("HostAndPort", hostAndPort); }
public void SetDownstreamRouteForThisRequest(DownstreamRoute downstreamRoute) { _requestScopedDataRepository.Add("DownstreamRoute", downstreamRoute); }
private void WhenIAddTheItem() { _requestScopedDataRepository.Add(_key, _toAdd); }
protected override Task <HttpResponseMessage> SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { return(_tracer.SendAsync(request, cancellationToken, x => _repo.Add("TraceId", x), (r, c) => base.SendAsync(r, c))); }