public Task TraceAsync(string data, DataOperation operation) { return(App.Current.Dispatcher.InvokeAsync(() => { if (!string.IsNullOrWhiteSpace(data)) { DataLenght += data.Length; var json = JObject.Parse(data); json.ToString(Formatting.Indented); var traceData = new TraceDataViewModel() { Operation = operation, Data = json.ToString() }; TraceLogs.Add(traceData); while (TraceLogs.Count > TraceLimit) { TraceLogs.RemoveAt(0); } } }).Task); }
public void RecordTraceLog(TraceLogs data) { string log = string.Format($"TraceId={data.TraceId}, RpcId={data.RpcId}, SystemID={data.SystemID}, SystemName={data.SystemName}, ContextType={data.ContextType}, InvokeID={data.InvokeID}"); //Console.WriteLine(log); File.AppendAllText("raven.log", log); }
/// <summary> /// 创建追踪基础数据 /// </summary> /// <param name="apiUri"></param> /// <param name="mediaType"></param> /// <param name="isTrace"></param> /// <param name="customHeaders"></param> /// <returns></returns> private TraceLogs CreateBaseTracer(string apiUri, string mediaType, bool isTrace, Dictionary <string, string> customHeaders) { if (isTrace) { // 请求头下发,埋点请求头 if (customHeaders == null) { customHeaders = new Dictionary <string, string>(); } var downStreamHeaders = _tracer.DownTraceHeaders(_httpContextAccessor.HttpContext); // 合并键值 customHeaders = customHeaders.Concat(downStreamHeaders).ToDictionary(k => k.Key, v => v.Value); } var traceLog = new TraceLogs() { ApiUri = apiUri, ContextType = mediaType, StartTime = DateTime.Now, }; if (isTrace) { _tracer.AddHeadersToTracer <TraceLogs>(_httpContextAccessor.HttpContext, traceLog); } return(traceLog); }
public void StopVideo() { Logs.Clear(); TraceLogs.Clear(); ResetChartViewModel(); IsPlayerEmbedded = false; SmoothStreamingSource = null; }
/// <summary> /// /// </summary> /// <param name="filterContext"></param> public override void OnActionExecuting(ActionExecutingContext filterContext) { ServiceContainer.Resolve <IInitRequestScopeContext>().BeginRequest(filterContext.HttpContext.Request); if (!filterContext.HasMarkerAttribute <NonTracingAttribute>()) { var request = filterContext.HttpContext.Request; var response = filterContext.HttpContext.Response; Header reqHeader = TracingContextData.GetDefaultRequestHeader(); TracingContextData.SetSubRpcID(reqHeader.RpcID + ".0"); TracingContextData.SetRequestHeader(reqHeader); if (!filterContext.HasMarkerAttribute <NotToLogAttribute>()) { TraceLogs trace = new TraceLogs(); trace.ContextType = ContextType.Server.ToString(); trace.StartTime = DateTime.Now; trace.MachineAddr = Util.TracingContextHelper.GetServerAddress(); trace.TraceId = reqHeader.TraceID; trace.RpcId = reqHeader.RpcID; trace.Protocol = request.Url.Scheme; trace.Environment = this.environment ?? EnvironmentConfig.Environment; trace.SystemID = this.systemID ?? EnvironmentConfig.SystemID; trace.SystemName = this.systemName ?? EnvironmentConfig.SystemName; //srs.InvokeID = string.Format("{0}_{1}", filterContext.ActionDescriptor.ControllerDescriptor.ControllerName.ToLower(), filterContext.ActionDescriptor.ActionName.ToLower()); //InvokeID trace.InvokeID = request.Url.AbsolutePath; string folder = filterContext.HttpContext.Request.Headers[Config.ResponseHeaderFolderKey]; if (!string.IsNullOrWhiteSpace(folder)) { trace.ServerHost = request.Url.Host + folder; } else { trace.ServerHost = request.Url.Host; } TraceExtensionOnActionExecuting(filterContext, trace); Util.TracingContextHelper.SetContextItem(Config.ServerRSKey, trace); } } base.OnActionExecuting(filterContext); }
public void SetStreamingSource(string source) { Logs.Clear(); TraceLogs.Clear(); ResetChartViewModel(); SmoothStreamingSource = source; IsPlayerEmbedded = true; if (!SavedSources.Contains(source)) { SavedSources.Add(source); SavedSourcesDataClient.Save(SavedSources); } }
//private static Dictionary<int, Tuple<string, string>> dict = new Dictionary<int, Tuple<string, string>>(); /// <summary> /// /// </summary> /// <param name="client"></param> /// <param name="systemID"></param> /// <param name="systemName"></param> /// <param name="environment">环境</param> /// <param name="TraceExtensionAct">TraceExtensionAct</param> public static void RegistTracing(this RpcHttpClient client, string systemID = null, string systemName = null, string environment = null, Action <HttpResponseMessage, RpcContext, TraceLogs> TraceExtensionAct = null) { RpcHttpClient.OnResponseDelegate onResponse = (response, rpcContext) => { TraceLogs trace = new TraceLogs(); trace.IsSuccess = true; trace.IsException = false; trace.SystemID = systemID ?? EnvironmentConfig.SystemID; trace.SystemName = systemName ?? EnvironmentConfig.SystemName; trace.Environment = environment ?? EnvironmentConfig.Environment; TraceExtensionAct?.Invoke(response, rpcContext, trace); FillClientSR(trace, response.RequestMessage, response, rpcContext); Record(trace); }; RpcHttpClient.OnErrorDelegate onError = (ex, request, rpcContext) => { TraceLogs trace = new TraceLogs(); trace.IsSuccess = false; trace.IsException = true; trace.SystemID = systemID ?? EnvironmentConfig.SystemID; trace.SystemName = systemName ?? EnvironmentConfig.SystemName; trace.Environment = environment ?? EnvironmentConfig.Environment; FillClientSR(trace, request, null, rpcContext); trace.Extensions.Add("Exception", Util.GetFullExceptionMessage(ex)); Record(trace); }; client.RequestContentDataHandler -= Client_RequestContentDataHandler; client.OnRequest -= Client_OnRequest; client.OnResponse -= onResponse; client.OnError -= onError; client.RequestContentDataHandler += Client_RequestContentDataHandler; client.OnRequest += Client_OnRequest; client.OnResponse += onResponse; client.OnError += onError; //dict[client.GetHashCode()] = new Tuple<string, string>(systemID, systemName); }
/// <summary> /// http请求结果转换 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="httpResponseMessage"></param> /// <param name="traceLogs"></param> /// <returns></returns> private T ToResult <T>(HttpResponseMessage httpResponseMessage, TraceLogs traceLogs) { if (typeof(T) == typeof(byte[])) { return((T)Convert.ChangeType(httpResponseMessage.Content.ReadAsByteArrayAsync().Result, typeof(T))); } if (typeof(T) == typeof(Stream)) { return((T)Convert.ChangeType(httpResponseMessage.Content.ReadAsStreamAsync().Result, typeof(T)));; } if (typeof(T) == typeof(String)) { var result = httpResponseMessage.Content.ReadAsStringAsync().Result; traceLogs.Response = result; return((T)Convert.ChangeType(result, typeof(T))); } else { var result = httpResponseMessage.Content.ReadAsStringAsync().Result; traceLogs.Response = result; return(_jsonHelper.DeserializeObject <T>(result)); } }
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); } }
/// <summary> /// /// </summary> /// <param name="srs"></param> private void Record(TraceLogs srs) { ServiceContainer.Resolve <ITracingRecord>().RecordTraceLog(srs); }
/// <summary> /// /// </summary> /// <param name="filterContext"></param> /// <param name="trace"></param> protected virtual void TraceExtensionOnActionExecuted(ActionExecutedContext filterContext, TraceLogs trace) { var jResult = filterContext.Result as JsonResult; if (jResult != null) { var responseModel = jResult.Data as IResponseModel; if (responseModel != null) { trace.Code = responseModel.GetCode(); //if (responseModel.Extension == null) //{ // responseModel.Extension = new List<Rpc.IContractModel.KeyValue<string, string>>(); //} //responseModel.Extension.Add(new Rpc.IContractModel.KeyValue<string, string>(nameof(Raven.Rpc.IContractModel.Header.TraceID), HttpContentData.GetRequestHeader().TraceID)); } //SearchKey var searchKey = jResult.Data as ISearchKey; if (searchKey != null) { trace.SearchKey = searchKey.GetSearchKey(); } trace.Extensions.Add(Config.ResultKey, Util.SerializerObjToString(jResult.Data)); } }
/// <summary> /// /// </summary> /// <param name="trace"></param> private static void Record(TraceLogs trace) { record.RecordTraceLog(trace); }
public TracerEvent(TraceLogs traceLogs) { this.Id = Guid.NewGuid(); this.Timestamp = DateTime.UtcNow; this.TraceLog = traceLogs; }
///// <summary> ///// ///// </summary> ///// <param name="data"></param> //public void RecordClientSR(ClientSR data) //{ // rabbitMQClient.Send(Config.TraceClientSRQueueName, data, true, true); //} ///// <summary> ///// ///// </summary> ///// <param name="data"></param> //public void RecordServerRS(ServerRS data) //{ // rabbitMQClient.Send(Config.TraceServerRSQueueName, data, true, true); //} /// <summary> /// /// </summary> /// <param name="data"></param> public void RecordTraceLog(TraceLogs data) { rabbitMQClient.Send(Config.TraceLogsQueueName, data, false, true); }
public static void TraceFormat(TraceLogs traceId, string s, object traced) { Tracer.TraceFormat(traceId, s, traced); }
public async Task Post(TraceLogs traceLogs) { await _eventBus.PublishAsync(new TracerEvent(traceLogs)); }
public void TraceFormat(TraceLogs logId, string s, object traced) { _Trace(logId, traced,s); }
/// <summary> /// /// </summary> /// <param name="actionContext"></param> public override void OnActionExecuting(HttpActionContext actionContext) { ServiceContainer.Resolve <IInitRequestScopeContext>().BeginRequest(actionContext.Request); if (!actionContext.HasMarkerAttribute <NonTracingAttribute>()) { var request = actionContext.Request; IRequestModel <Header> reqModel = null; Header reqHeader = null; if (actionContext.ActionArguments.Count > 0) { foreach (var dic in actionContext.ActionArguments) { //if (dic.Value is RequestModel) //{ // reqModel = dic.Value as RequestModel; // break; //} reqModel = dic.Value as IRequestModel <Header>; if (reqModel != null) { break; } } } if (reqModel == null && actionContext.Request.Content != null && string.Equals(actionContext.Request.Method.Method, "post", StringComparison.CurrentCultureIgnoreCase)) { try { reqModel = actionContext.Request.Content.ReadAsAsync <RequestModel>().Result; } catch { } if (reqModel != null) { actionContext.ActionArguments.Add(Guid.NewGuid().ToString("N"), reqModel); } } if (reqModel != null && reqModel.Header != null) { reqHeader = reqModel.Header; if (string.IsNullOrWhiteSpace(reqHeader.TraceID)) { reqHeader.TraceID = Generate.GenerateId();// Util.GetUniqueCode32(); } if (string.IsNullOrWhiteSpace(reqHeader.RpcID)) { reqHeader.RpcID = "0"; } //HttpContentData.SetTrackID(reqHeader.TraceID); //HttpContentData.SubRpcID = reqHeader.RpcID + ".0"; //var header = HttpContentData.CloneRequestHeader(reqModel.Header); //header.RpcID = header.RpcID + ".0"; } else { reqHeader = TracingContextData.GetDefaultRequestHeader(); //HttpContentData.SetTrackID(reqHeader.TraceID); } TracingContextData.SetSubRpcID(reqHeader.RpcID + ".0"); TracingContextData.SetRequestHeader(reqHeader); //HttpContentData.RequestHeader = reqHeader; //Not To Log if (!actionContext.HasMarkerAttribute <NotToLogAttribute>()) { TraceLogs trace = new TraceLogs(); trace.ContextType = ContextType.Server.ToString(); trace.StartTime = DateTime.Now; trace.MachineAddr = Util.TracingContextHelper.GetServerAddress(); trace.TraceId = reqHeader.TraceID; trace.RpcId = reqHeader.RpcID; trace.Protocol = string.Format("{0}/{1}", actionContext.Request.RequestUri.Scheme, actionContext.Request.Version); trace.Environment = this.environment ?? EnvironmentConfig.Environment; trace.SystemID = this.systemID ?? EnvironmentConfig.SystemID; trace.SystemName = this.systemName ?? EnvironmentConfig.SystemName; //InvokeID trace.InvokeID = request.RequestUri.AbsolutePath; IEnumerable <string> folder; if (actionContext.Request.Headers.TryGetValues(Config.ResponseHeaderFolderKey, out folder)) { trace.ServerHost = actionContext.Request.RequestUri.Host + folder.FirstOrDefault(); } else { trace.ServerHost = actionContext.Request.RequestUri.Host; } //SearchKey var searchKey = reqModel as ISearchKey; if (searchKey != null) { trace.SearchKey = searchKey.GetSearchKey(); } TraceExtensionOnActionExecuting(actionContext, trace); //srs.InvokeID = string.Format("{0}_{1}", actionContext.ControllerContext.ControllerDescriptor.ControllerName.ToLower(), actionContext.ActionDescriptor.ActionName.ToLower()); //if (actionContext.ActionArguments != null && actionContext.ActionArguments.Count > 0) //{ // srs.Extension.Add(Config.ParamsKey, actionContext.ActionArguments); //} //ServerRS Log Data TODO Util.TracingContextHelper.SetContextItem(Config.ServerRSKey, trace); } } base.OnActionExecuting(actionContext); }
/// <summary> /// /// </summary> /// <param name="actionExecutedContext"></param> /// <param name="trace"></param> protected virtual void TraceExtensionOnActionExecuted(HttpActionExecutedContext actionExecutedContext, TraceLogs trace) { if (actionExecutedContext.Response != null) { IResponseModel responseModel = null; if (actionExecutedContext.Response.TryGetContentValue <IResponseModel>(out responseModel)) { trace.Code = responseModel.GetCode(); trace.Extensions.Add(Config.ResultKey, Util.SerializerObjToString(responseModel)); //if (responseModel.Extension == null) //{ // responseModel.Extension = new List<Rpc.IContractModel.KeyValue<string, string>>(); //} //responseModel.Extension.Add(new Rpc.IContractModel.KeyValue<string, string>(nameof(Raven.Rpc.IContractModel.Header.TraceID), trace.TraceId)); } } }
/// <summary> /// /// </summary> /// <param name="actionContext"></param> /// <param name="trace"></param> protected virtual void TraceExtensionOnActionExecuting(HttpActionContext actionContext, TraceLogs trace) { trace.Extensions.Add(nameof(actionContext.Request.RequestUri.PathAndQuery), actionContext.Request.RequestUri.PathAndQuery); if (actionContext.ActionArguments != null && actionContext.ActionArguments.Count > 0) { trace.Extensions.Add(Config.ParamsKey, Util.SerializerObjToString(actionContext.ActionArguments)); } }
/// <summary> /// /// </summary> /// <param name="filterContext"></param> /// <param name="trace"></param> protected virtual void TraceExtensionOnActionExecuting(ActionExecutingContext filterContext, TraceLogs trace) { trace.Extensions.Add(nameof(filterContext.HttpContext.Request.Url.PathAndQuery), filterContext.HttpContext.Request.Url.PathAndQuery); if (filterContext.ActionParameters != null && filterContext.ActionParameters.Count > 0) { trace.Extensions.Add(Config.ParamsKey, Util.SerializerObjToString(filterContext.ActionParameters)); } var form = filterContext.HttpContext.Request.Form; if (form != null && form.Count > 0) { var dict = new Dictionary <string, object>(); foreach (var k in form.AllKeys) { dict.Add(k, form[k]); } trace.Extensions.Add(Config.FormKey, Util.SerializerObjToString(dict)); } }
public void Trace(TraceLogs logId, object traced) { _Trace(logId, traced, null); }
public static void Trace(TraceLogs traceId, object traced) { Tracer.Trace(traceId, traced); }
public ErrorLogger GetLog(TraceLogs logId) { var log = _traceLogs[logId]; if (null == log) { log = ErrorLogger.GetLogger("_trace_" + logId); _traceLogs.Add(logId, log); var logger = (ErrorLogger)log; logger.InfoFormat("Trace Logs Enabled: {0}", IsEnabled); var openTraceLogs = ConfigUtils.GetFlag(TraceOpenLogs); logger.InfoFormat("Trace Logs Automatically Opened: {0}", openTraceLogs); logger.InfoFormat("Current Trace: {0}", Enum.GetName(typeof(TraceLogs), logId)); if (openTraceLogs) { Process.Start(logger.FilePath); } } return log as ErrorLogger; }
//private static void Client_OnResponse(HttpResponseMessage response, RpcContext rpcContext) //{ // TraceLogs trace = new TraceLogs(); // trace.IsSuccess = true; // trace.IsException = false; // FillClientSR(trace, response.RequestMessage, rpcContext); // Record(trace); //} //private static void Client_OnError(Exception ex, HttpRequestMessage request, RpcContext rpcContext) //{ // TraceLogs trace = new TraceLogs(); // trace.IsSuccess = false; // trace.IsException = true; // FillClientSR(trace, request, rpcContext); // trace.Extension.Add("Exception", Util.GetFullExceptionMessage(ex)); // Record(trace); //} /// <summary> /// /// </summary> /// <param name="trace"></param> /// <param name="request"></param> /// <param name="response"></param> /// <param name="rpcContext"></param> private static void FillClientSR(TraceLogs trace, HttpRequestMessage request, HttpResponseMessage response, RpcContext rpcContext) { trace.ContextType = ContextType.Client.ToString(); //var requestHeader = TracingContextData.GetRequestHeader(); //raven Request Header var uri = request.RequestUri; //int index = uri.AbsoluteUri.IndexOf("?"); //if (index > 0) //{ // trace.ServiceMethod = uri.AbsoluteUri.Substring(0, index); //} //else //{ // trace.ServiceMethod = uri.AbsoluteUri; //} trace.MachineAddr = Util.TracingContextHelper.GetServerAddress(); trace.InvokeID = uri.AbsolutePath; trace.ServerHost = uri.Host; //trace.Extension.Add(nameof(uri.AbsolutePath), uri.AbsolutePath); trace.Extensions.Add(nameof(uri.PathAndQuery), uri.PathAndQuery); //trace.Extension.Add(nameof(uri.Host), uri.Host); trace.Extensions.Add(nameof(rpcContext.RequestModel), Util.SerializerObjToString(rpcContext.RequestModel)); trace.Extensions.Add(nameof(rpcContext.ResponseModel), Util.SerializerObjToString(rpcContext.ResponseModel)); trace.ResponseSize = rpcContext.ResponseSize; trace.Protocol = uri.Scheme; trace.ProtocolHeader.Add("RequestHeaders", new Dictionary <string, string> { { "Accept", request.Headers.Accept.ToString() }, { "Accept-Encoding", request.Headers.AcceptEncoding.ToString() }, { "Content-Type", request.Content?.Headers?.ContentType?.ToString() }, }); if (response != null) { trace.ProtocolHeader.Add("ResponseHeaders", new Dictionary <string, string> { { "Content-Encoding", response.Content?.Headers?.ContentEncoding?.ToString() }, { "Content-Type", response.Content?.Headers?.ContentType?.ToString() }, }); } //trace.SendSTime = rpcContext.SendStartTime; //trace.ReceiveETime = rpcContext.ReceiveEndTime; //trace.ExceptionTime = rpcContext.ExceptionTime; trace.StartTime = rpcContext.SendStartTime; if (rpcContext.ReceiveEndTime.HasValue) { trace.EndTime = rpcContext.ReceiveEndTime.Value; trace.TimeLength = (trace.EndTime - trace.StartTime).TotalMilliseconds; } else if (rpcContext.ExceptionTime.HasValue) { trace.EndTime = rpcContext.ExceptionTime.Value; trace.TimeLength = (trace.EndTime - trace.StartTime).TotalMilliseconds; } //trace.TimeLength = trace.ReceiveETime.HasValue ? (trace.ReceiveETime.Value - trace.SendSTime).TotalMilliseconds : 0D; //trace.RpcId = modelHeader.RpcID; //var reqModel = rpcContext.RequestModel as IRequestModel<Header>; //if (reqModel != null && reqModel.Header != null) //{ // trace.RpcId = rpcContext.Items[RpcIDKey].ToString(); //} //if modelHeader is null, create new traceID trace.RpcId = rpcContext.Items[RpcIDKey].ToString(); trace.TraceId = rpcContext.Items[TraceIDKey].ToString(); if (rpcContext.ResponseModel != null) { var resModel = rpcContext.ResponseModel as IResponseModel; if (resModel != null) { trace.Code = resModel.GetCode(); } //SearchKey var searchKey = rpcContext.ResponseModel as ISearchKey; if (searchKey != null) { trace.SearchKey = searchKey.GetSearchKey(); } } }
public virtual void RecordTraceLog(TraceLogs data) { }
void ProcessEvent(Log log) { if (log.Type != VideoLogTypes.Trace && log.Type != VideoLogTypes.VideoQualitySnapshot) { // weed these out, there are way too many of them. This is consistent with what a logagent that sends to the server would do too. Logs.Add(log); } IEnumerable <ChartViewModel> charts = ChartViewModel.Charts; switch (log.Type) { case VideoLogTypes.VideoQuality: QualityData = new QualityDataViewModel(log.CastLog <VideoQualityLog>()); break; case VideoLogTypes.VideoQualitySnapshot: VideoQualitySnapshotLog qualityLog = log.CastLog <VideoQualitySnapshotLog>(); foreach (ChartViewModel chartVM in charts) { if (log.Data.ContainsKey(chartVM.QualityAttribute)) { if (chartVM.QualityAttribute == VideoLogAttributes.PerceivedBandwidth) { chartVM.AddDataPoint(qualityLog.PerceivedBandwidth.GetValueOrDefault(0) / 1024); } else { chartVM.AddDataPoint(Convert.ToDouble(log.Data[chartVM.QualityAttribute])); } } } ClientIP = qualityLog.ClientIP.ToString(); EdgeServerIP = qualityLog.EdgeIP; SmoothStreamingUrl = qualityLog.VideoUrl; ProcessCPU = qualityLog.ProcessCPULoad.GetValueOrDefault(0); SystemCPU = qualityLog.SystemCPULoad.GetValueOrDefault(0); break; case VideoLogTypes.VideoStarted: case VideoLogTypes.VideoLoaded: VideoLoadLog loadLog = log.CastLog <VideoLoadLog>(); var bitrateChartData = charts.First(vm => vm.QualityAttribute == VideoLogAttributes.BitRate); if (loadLog.MaxBitRate.HasValue) { bitrateChartData.MaxValue = loadLog.MaxBitRate.Value; } ClientIP = loadLog.ClientIP.ToString(); EdgeServerIP = loadLog.EdgeIP; SmoothStreamingUrl = loadLog.VideoUrl; break; case VideoLogTypes.Trace: TraceLogs.Add(log.CastLog <TraceLog>()); break; } }
private void _Trace(TraceLogs logId, object traced, string s) { if(!IsEnabled) { return; } var log = GetLog(logId); if (log.MaxLevel < 4) { return; } var frame = new StackFrame(3); //must take into account intermediate callers to get to calling frame var method = frame.GetMethod(); var type = method.DeclaringType; var name = method.Name; #if !DEBUG log.WarnFormat("{0}.{1} # {2}", type, name, "Trace Call outside of DEBUG block!"); #endif var sTraced = (traced is ValueType || traced is string) ? traced.ToString():traced.DumpT(); if (null == s) { var s1 = string.Format("{0}.{1} # {2}", type, name, sTraced); log.Debug(s1); return; } var s2 = string.Format("{0}.{1} # {2}", type, name, s); log.Log(4, s2, sTraced); }
/// <summary> /// get 请求 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="serviceName"></param> /// <param name="webApiPath"></param> /// <param name="scheme"></param> /// <param name="customHeaders"></param> /// <param name="MediaType"></param> /// <param name="isBuried"></param> /// <returns></returns> public T GetWebApi <T>(string serviceName, string webApiPath, string scheme = "http", Dictionary <string, string> customHeaders = null, string MediaType = "application/json", bool isTrace = false) { #region 负载寻址 var _load = _loadBalancerHouse.Get(serviceName).GetAwaiter().GetResult(); if (_load == null) { throw new ArgumentNullException(nameof(_load)); } var HostAndPort = _load.Lease().GetAwaiter().GetResult(); if (HostAndPort == null) { throw new ArgumentNullException(nameof(HostAndPort)); } string baseAddress = $"{scheme}://{HostAndPort.ToString()}/"; webApiPath = webApiPath.TrimStart('/'); #endregion #region 游请求头处理 if (isTrace) { // 请求头下发,埋点请求头 if (customHeaders == null) { customHeaders = new Dictionary <string, string>(); } var downStreamHeaders = _tracer.DownTraceHeaders(_httpContextAccessor.HttpContext); // 合并键值 customHeaders = customHeaders.Concat(downStreamHeaders).ToDictionary(k => k.Key, v => v.Value); } #endregion #region 请求埋点 var traceLog = new TraceLogs() { ApiUri = $"{baseAddress}{webApiPath}", ContextType = MediaType, StartTime = DateTime.Now, }; if (isTrace) { _tracer.AddHeadersToTracer <TraceLogs>(_httpContextAccessor.HttpContext, traceLog); if (customHeaders.TryGetValue(TracerKeys.TraceSeq, out string value)) { traceLog.ParentSeq = value; } } #endregion #region http 请求 var request = new HttpRequestMessage { RequestUri = new Uri($"{baseAddress}{webApiPath}"), Method = HttpMethod.Get }; request.Headers.Clear(); request.Headers.Accept.Clear(); if (customHeaders != null) { foreach (KeyValuePair <string, string> customHeader in customHeaders) { request.Headers.Add(customHeader.Key, customHeader.Value); } } request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaType)); traceLog.Request = request.RequestUri.Query; try { var httpResponseMessage = _httpClient.SendAsync(request, HttpCompletionOption.ResponseContentRead).GetAwaiter().GetResult(); if (httpResponseMessage.IsSuccessStatusCode) { traceLog.IsSuccess = true; traceLog.IsException = false; if (typeof(T) == typeof(byte[])) { return((T)Convert.ChangeType(httpResponseMessage.Content.ReadAsByteArrayAsync().Result, typeof(T))); } if (typeof(T) == typeof(Stream)) { return((T)Convert.ChangeType(httpResponseMessage.Content.ReadAsStreamAsync().Result, typeof(T)));; } if (typeof(T) == typeof(String)) { var result = httpResponseMessage.Content.ReadAsStringAsync().Result; traceLog.Response = result; return((T)Convert.ChangeType(result, typeof(T))); } else { var result = httpResponseMessage.Content.ReadAsStringAsync().Result; traceLog.Response = result; return(_jsonHelper.DeserializeObject <T>(result)); } } } catch (Exception ex) { traceLog.IsException = true; _logger.LogError(ex, $"服务{serviceName},路径{webApiPath}接口请求异常"); } finally { if (isTrace) { traceLog.EndTime = DateTime.Now; traceLog.TimeLength = Math.Round((traceLog.EndTime - traceLog.StartTime).TotalMilliseconds, 4); _tracer.PublishAsync <TraceLogs>(traceLog).GetAwaiter(); } } #endregion throw new Exception($"服务{serviceName},路径{webApiPath}接口请求异常"); }