public static IApplicationBuilder UseCocohub(this IApplicationBuilder builder)
{
var httpContextAccessor = builder.ApplicationServices.GetService(typeof(IHttpContextAccessor)) as IHttpContextAccessor;
TracerContext.Configure(httpContextAccessor);
return(builder.UseMiddleware <CocohubMiddleware>());
}
public Task Send(IList <IClientSpan> entities)
{
//1 group and convert trace span trees
//2 send spans by relations
var sameTraceSpanGroups = entities.OrderBy(x => x.StartUtc)
.GroupBy(x => new { x.TracerId, x.TraceId });
var tracerContext = TracerContext.Resolve();
foreach (var sameTraceSpanGroup in sameTraceSpanGroups)
{
var logger = SimpleLogSingleton <JaegerTracerFactory> .Instance.Logger;
logger.LogInfo(string.Format("Send ClientSpans => {0}: {1}", sameTraceSpanGroup.Key, sameTraceSpanGroup.Count()));
//var groupKey = sameTraceSpanGroup.Key;
var sameTraceSpans = sameTraceSpanGroup.ToList();
var myTreeConvert = MyTreeConvert.Instance;
var myTrees = myTreeConvert
.MakeTrees(sameTraceSpans, span => span.ToLocateCurrentKey(), span => span.ToLocateParentKey())
.OrderBy(x => x.Value.StartUtc).ToList();
foreach (var myTree in myTrees)
{
SendSpanTree(tracerContext, myTree);
}
}
return(Task.FromResult(0));
}
public void SomeWorkNeedTrace()
{
//will use "FooService-GetUserInfo" span
var tracer = TracerContext.GetCurrent();
tracer.ActiveSpan.Log("another log from FooService's SomeWork");
Task.Delay(100).Wait();
}
private static void SetupJaeger()
{
var jaegerTracerConfig = new JaegerTracerConfig();
jaegerTracerConfig.DefaultTracerId = "Default-Tracer";
jaegerTracerConfig.TraceEndPoint = "http://localhost:14268/api/traces";
var tracerFactory = new JaegerTracerFactory(jaegerTracerConfig);
//replace null
var tracerContext = new TracerContext(tracerFactory);
TracerContext.Resolve = () => tracerContext;
}
public string GetUserInfo(string username)
{
var tracer = TracerContext.GetCurrent();
using (var scope = tracer.BuildSpan("FooData-GetUserInfo").StartActive(true))
{
//按需使用
scope.Span.Log("a log from FooData");
scope.Span.SetTag("username", username);
Task.Delay(20).Wait();
var result = $"some info of {username}";
return(result);
}
}
public string GetUserInfo(string username)
{
var tracer = TracerContext.GetCurrent();
using (var scope = tracer.BuildSpan("FooApi-GetUserInfo").StartActive(true))
{
var result = _fooService.GetUserInfo(username);
//按需使用
scope.Span.Log("a log from FooApi");
scope.Span.SetTag("username", username);
return(result);
}
}
public void TraceLeave(string methodInfo, long startTicks, long endTicks, string[] paramNames,
object[] paramValues)
{
string returnValue = null;
if (paramNames != null)
{
StringBuilder parameters = new StringBuilder();
for (int i = 0; i < paramNames.Length; i++)
{
if (paramNames[i] == "$exception")
{
var value = paramValues[i].ToString();
paramValues[i] = value;
}
parameters.AppendFormat("{0}={1}", paramNames[i] ?? "$return",
paramValues[i] == null ? NullString : paramValues[i].ToString()
.Replace("\r\n", string.Empty)
.Replace("\"", string.Empty)
.Replace(@"\", @"/"));
if (i < paramNames.Length - 1)
{
parameters.Append(", ");
}
}
returnValue = parameters.ToString();
}
double timeTaken = ConvertTicksToMilliseconds(endTicks - startTicks);
string message = String.Empty;
if (TracerContext.Tracer == null)
{
message = String.Format(_textReturn, methodInfo, returnValue, timeTaken);
}
else
{
message = String.Format(_textReturnWithTracer, methodInfo, returnValue, timeTaken, TracerContext.Tracer.TracerId, TracerContext.Tracer.SpanId);
}
Log.Info(message);
TracerContext.Leave();
}
public void Can_trace_command_trees()
{
using (var context = new TracerContext())
{
context.TracerEntities.Add(
new TracerEntity
{
Id = 1,
Name = "Pineapple Lumps"
});
using (var commandTracer = new CommandTracer(context))
{
context.SaveChanges();
var interceptedCommandTree = commandTracer.CommandTrees.Single();
Assert.IsType<DbInsertCommandTree>(interceptedCommandTree);
}
}
}
public void Can_trace_command_trees()
{
using (var context = new TracerContext())
{
context.TracerEntities.Add(
new TracerEntity
{
Id = 1,
Name = "Pineapple Lumps"
});
using (var commandTracer = new CommandTracer(context))
{
context.SaveChanges();
var interceptedCommandTree = commandTracer.CommandTrees.Single();
Assert.IsType <DbInsertCommandTree>(interceptedCommandTree);
}
}
}
public void Can_trace_commands_and_execution_cancelled()
{
using (var context = new TracerContext())
{
context.TracerEntities.Add(
new TracerEntity
{
Id = 1,
Name = "Pineapple Lumps"
});
CommandTracer commandTracer;
using (commandTracer = new CommandTracer(context))
{
context.SaveChanges();
var interceptedCommand = commandTracer.DbCommands.Single();
Assert.Equal(
"INSERT [dbo].[TracerEntities]([Id], [Name])\r\nVALUES (@0, @1)\r\n",
interceptedCommand.CommandText);
Assert.Equal(2, interceptedCommand.Parameters.Count);
}
context.TracerEntities.Add(
new TracerEntity
{
Id = 2,
Name = "Orange squash gums"
});
context.SaveChanges();
Assert.Equal(1, commandTracer.DbCommands.Count());
Assert.Null(context.TracerEntities.SingleOrDefault(p => p.Id == 1));
Assert.NotNull(context.TracerEntities.SingleOrDefault(p => p.Id == 2));
}
}
public void Can_trace_commands_and_execution_cancelled()
{
using (var context = new TracerContext())
{
context.TracerEntities.Add(
new TracerEntity
{
Id = 1,
Name = "Pineapple Lumps"
});
CommandTracer commandTracer;
using (commandTracer = new CommandTracer(context))
{
context.SaveChanges();
var interceptedCommand = commandTracer.DbCommands.Single();
Assert.Equal(
"INSERT [dbo].[TracerEntities]([Id], [Name])\r\nVALUES (@0, @1)\r\n",
interceptedCommand.CommandText);
Assert.Equal(2, interceptedCommand.Parameters.Count);
}
context.TracerEntities.Add(
new TracerEntity
{
Id = 2,
Name = "Orange squash gums"
});
context.SaveChanges();
Assert.Equal(1, commandTracer.DbCommands.Count());
Assert.Null(context.TracerEntities.SingleOrDefault(p => p.Id == 1));
Assert.NotNull(context.TracerEntities.SingleOrDefault(p => p.Id == 2));
}
}
/// <summary>
/// Starts the new trace.
/// </summary>
private void startNewTrace()
{
traceBindingList.Clear();
fileContentBindingList.Clear();
traceElementList.Clear();
traceFileContentListBox.ActiveLineNumber = -1;
traceFileContentListBox.ActualFileName = "null";
labelTraceCount.Text = "0";
getUserContext().ComportSelection = comportWindow.Comport;
getUserContext().BaudrateSelection = comportWindow.Baudrate;
TracerContext.getInstance().Comport = comportWindow.Comport;
TracerContext.getInstance().Baudrate = comportWindow.Baudrate;
TracerContext.getInstance().TraceActive = true;
TracerFactory.getInstance().getInterface().startTracing();
progressTraceWindow.StartPosition = FormStartPosition.CenterParent;
progressTraceWindow.ShowDialog(this);
}
public void TraceEnter(string methodInfo, string[] paramNames, object[] paramValues)
{
string argInfo = string.Empty;
if (paramNames != null)
{
StringBuilder parameters = new StringBuilder();
for (int i = 0; i < paramNames.Length; i++)
{
parameters.AppendFormat("{0}={1}", paramNames[i],
paramValues[i] == null ? NullString : paramValues[i].ToString()
.Replace("\r\n", string.Empty)
.Replace("\"", string.Empty)
.Replace(@"\", @"/"));
if (i < paramNames.Length - 1)
{
parameters.Append(", ");
}
}
argInfo = parameters.ToString();
}
TracerContext.Enter();
string message = String.Empty;
if (TracerContext.Tracer == null)
{
message = String.Format(_textEnter, methodInfo, argInfo);
}
else
{
message = String.Format(_textEnterWithTracer, methodInfo, argInfo, TracerContext.Tracer.TracerId, TracerContext.Tracer.SpanId, TracerContext.IP);
}
Log.Info(message);
}
/// <summary>
/// Gets the context.
/// </summary>
/// <returns></returns>
protected TracerContext getContext()
{
return(TracerContext.getInstance());
}
private void SendSpanTree(TracerContext tracerContext, MyTree <IClientSpan> spanTree)
{
var clientSpan = spanTree.Value;
var tracer = tracerContext.Current(clientSpan.TracerId);
using (var scope = tracer.BuildSpan(clientSpan.OpName)
.WithStartTimestamp(clientSpan.StartUtc)
.StartActive(false))
{
foreach (var bag in clientSpan.Bags)
{
if (bag.Value == null)
{
scope.Span.SetTag(bag.Key, null);
continue;
}
scope.Span.SetTag(bag.Key, bag.Value);
}
var logGroups = clientSpan.Logs.GroupBy(x => x.Value.CreateAt).ToList();
foreach (var logGroup in logGroups)
{
var createAt = logGroup.Key;
var logInfos = logGroup.Select(x => new KeyValuePair <string, object>(x.Key, x.Value.Value)).ToList();
scope.Span.Log(createAt, logInfos);
}
foreach (var tag in clientSpan.Tags)
{
if (tag.Value == null)
{
scope.Span.SetTag(tag.Key, null);
continue;
}
if (tag.Value is bool boolValue)
{
scope.Span.SetTag(tag.Key, boolValue);
}
else if (tag.Value is int intValue)
{
scope.Span.SetTag(tag.Key, intValue);
}
else if (tag.Value is double doubleValue)
{
scope.Span.SetTag(tag.Key, doubleValue);
}
scope.Span.SetTag(tag.Key, tag.Value.ToString());
}
//cascade process children
foreach (var childTree in spanTree.Children)
{
SendSpanTree(tracerContext, childTree);
}
if (clientSpan.FinishUtc != null)
{
//throw ex?
scope.Span.Finish(clientSpan.FinishUtc.Value);
}
}
}
/// <summary>
/// Ons the selected index changed.
/// </summary>
/// <param name="o">The o.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void onTraceListBoxSelectedIndexChanged(object o, EventArgs e)
{
debug("MainWindow.onTraceListBoxSelectedIndexChanged()");
TraceGuiListItem traceItem = traceListBox.SelectedItem as TraceGuiListItem;
if (traceItem == null)
{
return;
}
if (traceFileContentListBox.ActualFileName.CompareTo(traceItem.FileName) == 0)
{
labelTraceFileLine.Text = Convert.ToString(traceItem.LineNumber + 1);
traceFileContentListBox.ActiveLineNumber = traceItem.LineNumber + 1;
// ---------------------------------traceFileContentListBox.SelectedIndex = traceItem.LineNumber;
//traceFileContentListBox.Refresh();
//return;
}
labelTraceFilePath.Text = traceItem.FileName;
labelTraceFileLine.Text = Convert.ToString(traceItem.LineNumber + 1);
traceFileContentListBox.ActiveLineNumber = traceItem.LineNumber + 1;
traceFileContentListBox.ActualFileName = traceItem.FileName;
//fileContentBindingList.Clear(); ------------------------------------------------------
this.traceFileContentTextBox.Clear();
string[] fileContent = File_Factory.FileFactory.getInstance().getFileContentAsLineArray(TracerContext.getInstance().BasicFilePath + traceItem.FileName);
for (int i = 0; i < fileContent.Length; i++)
{
// -------------------------fileContentBindingList.Add(new TraceFileContentElement(i + 1, fileContent[i]));
if (i == traceItem.LineNumber)
{
this.traceFileContentTextBox.SelectionBackColor = Color.Blue;
}
else
{
this.traceFileContentTextBox.SelectionBackColor = Color.DarkBlue;
}
this.traceFileContentTextBox.AppendText((i + 1) + "\t");
this.traceFileContentTextBox.AppendText(fileContent[i]);
this.traceFileContentTextBox.AppendText("\n");
}
traceFileContentTextBox.SelectionStart = traceFileContentTextBox.Find(traceFileContentTextBox.Lines[traceItem.LineNumber]);
traceFileContentTextBox.ScrollToCaret();
return;
}
private static void AddTraceClients(IServiceCollection services, IConfiguration configuration)
{
services.AddSingleton <IClientTracerApi, ClientTracerApi>();
services.AddSingleton <CommandQueue>();
services.AddSingleton <CommandQueueTask>();
//SimpleTrace.dll
var assemblyToScan = Assembly.GetAssembly(typeof(ICommandLogistic));
//All IClientSpanProcess
services.AddSingletonFromAssembly(assemblyToScan, typeof(IClientSpanProcess));
//All ICommandLogistic and KnownCommands
services.AddSingletonFromAssembly(assemblyToScan, typeof(ICommandLogistic));
services.AddSingleton(sp =>
{
var knownCommands = KnownCommands.Instance;
var commandLogistics = sp.GetServices <ICommandLogistic>().ToList();
foreach (var commandLogistic in commandLogistics)
{
knownCommands.Register(commandLogistic);
}
return(knownCommands);
});
//TraceConfig
var traceConfig = TryLoadTraceConfig(configuration);
services.AddSingleton(traceConfig);
//CommandQueueTaskLoop
services.AddSingleton(sp =>
{
var commandQueueTaskLoop = new CommandQueueTaskLoop();
var queueTask = sp.GetService <CommandQueueTask>();
var knownCommands = sp.GetService <KnownCommands>();
var commandLogistics = sp.GetServices <ICommandLogistic>().ToList();
foreach (var commandLogistic in commandLogistics)
{
knownCommands.Register(commandLogistic);
}
commandQueueTaskLoop.Init(
TimeSpan.FromSeconds(traceConfig.FlushIntervalSecond),
queueTask,
sp.GetService <CommandQueue>(),
sp.GetServices <ICommandLogistic>(),
sp.GetServices <IClientSpanProcess>(),
DateHelper.Instance.GetDateNow);
return(commandQueueTaskLoop);
});
services.AddSingleton(CommandQueueProcessLogs.Instance);
//IClientSpanRepository
if (traceConfig.TraceSaveProcessEnabled)
{
services.AddSingleton <IClientSpanRepository, ClientSpanRepository>();
}
else
{
services.AddSingleton <IClientSpanRepository, NullClientSpanRepository>();
}
//TracerContext
var tracerContext = TracerContext.Resolve();
services.AddSingleton <TracerContext>(tracerContext);
if (traceConfig.TraceSendProcessEnabled)
{
//JaegerTracerConfig
var jaegerTracerConfig = new JaegerTracerConfig();
jaegerTracerConfig.DefaultTracerId = traceConfig.DefaultTracerId;
jaegerTracerConfig.TraceEndPoint = traceConfig.TraceEndPoint;
services.AddSingleton(jaegerTracerConfig);
//ITracerFactory and TracerContext
var tracerFactory = new JaegerTracerFactory(jaegerTracerConfig);
services.AddSingleton <ITracerFactory>(tracerFactory);
tracerContext.Factory = tracerFactory;
//ITraceSender
services.AddSingleton <ITraceSender, JaegerTraceSender>();
//log TraceConfig
var tracer = tracerContext.Current();
using (var scope = tracer.BuildSpan("LogObject").StartActive(true))
{
scope.Span.SetTag("Name", "TraceConfig");
var dictionary = MyModelHelper.GetKeyValueDictionary(traceConfig);
foreach (var kv in dictionary)
{
scope.Span.Log(kv.Key + " : " + kv.Value);
}
}
}
else
{
services.AddSingleton <ITracerFactory, NullTracerFactory>();
services.AddSingleton <ITraceSender, NullTraceSender>();
}
}
/// <summary>
/// Starts the tracing.
/// </summary>
public void startTracing()
{
TracerContext.getInstance().TraceActive = true;
engine.start(50);
}
public void setConnectionInterface(ICommonConnectionInterface iConnection)
{
TracerContext.getInstance().Connection = iConnection;
}
/// <summary>
/// Stops the tracing.
/// </summary>
public void stopTracing()
{
TracerContext.getInstance().TraceActive = false;
engine.stop();
}
