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}接口请求异常");
}
///// <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);
}
