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