public override Task <NullResponse> AfterMethodInvoked(MethodActiveReuqest request, ServerCallContext context)
{
return(Task.Run(() =>
{
var item = new MethodTracer()
{
NodeID = request.NodeID,
FileName = request.FileName,
LineNumber = request.LineNumber,
EventID = request.EventID,
MethodEventID = request.MethodEventID,
MethodID = request.TimeStamp,
TraceID = request.TraceID,
MethodName = request.MethodName,
PreMethodEventID = request.PreMethodEventID,
TimeStamp = request.TimeStamp
};
if (request.CustomData != null)
{
var keys = request.CustomData.Keys.ToArray();
for (int i = 0; i < keys.Length; i++)
{
item.CustomData.Add(keys[i], request.CustomData[keys[i]]);
}
}
_dbInstance.SaveItem(item);
return new NullResponse();
}));
}
public override async Task AfterMethodInvokedAsync(MethodTracer info)
{
if (info == null)
{
return;
}
await Task.Run(() => { System.Console.WriteLine(GetInfo(info, new StringBuilder($"{nameof(AfterMethodInvokedAsync)}:"))); });
}
void InitStore()
{
using (MethodTracer tracer = new MethodTracer(m_logger))
{
m_store = new ConfigStore(m_settings.StoreConnectString, m_settings.QueryTimeout);
this.LoadDomains();
}
}
private void SaveMethodInfo(MethodTracer _)
{
//问题是TraceID完全一样啊~~~~~
//那应该就是webapi的事情,他可以去node里头查找,也以来methodDB来查找
//目前应该还没有需要通信MethodTracer的地方,临时统计即可.
//根据eventID查询
//根据methodeventID 查询
//根据PreMethodEventID查询
}
public void Resolve()
{
using (MethodTracer tracer = new MethodTracer())
{
Connector.EndNode = Process(StartPoint);
Connector.TraversedNodes = new List <NNodeX>(this.allPoints);
Connector.PathNodes = new List <NNodeX>();
Connector.MakePath(Connector.EndNode);
}
}
public void ThreadTimeShouldEqualSumOfHighestLevelMethodsTimes()
{
ITracer tracer = new MethodTracer();
ClassWithSeveralMethods classWithSeveralMethods = new ClassWithSeveralMethods(tracer);
classWithSeveralMethods.MethodWithInnerMethods();
TraceResult traceResult = tracer.GetTraceResult();
Assert.Equal(traceResult.Threads[0].Time, traceResult.Threads[0].Methods.Select(method => method.Time).Sum());
}
public static int Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Program.Program_UnhandledException);
using (new MethodTracer(MethodBase.GetCurrentMethod()))
{
MethodTracer.TraceAssembly();
Program program = new Program();
return(program.Run(args));
}
}
public void FirstMethodResultShouldContainOneInnerMethod()
{
ITracer tracer = new MethodTracer();
ClassWithSeveralMethods classWithSeveralMethods = new ClassWithSeveralMethods(tracer);
classWithSeveralMethods.MethodWithInnerMethods();
TraceResult traceResult = tracer.GetTraceResult();
Assert.Single(traceResult.Threads[0].Methods[0].Methods);
}
public void MethodTimeShouldBeMoreOrEqualThanSleepTime()
{
ITracer tracer = new MethodTracer();
ClassWithSleepMethod classWithSleepMethod = new ClassWithSleepMethod(tracer);
classWithSleepMethod.MethodWithSleep();
TraceResult traceResult = tracer.GetTraceResult();
Assert.True(traceResult.Threads[0].Methods[0].Time >= 100);
}
public void TraceResultShouldContainThreeThreads()
{
ITracer tracer = new MethodTracer();
MultiThreadingClass multiThreadingClass = new MultiThreadingClass(tracer);
multiThreadingClass.RunThreeThreads();
TraceResult traceResult = tracer.GetTraceResult();
Assert.Equal(3, traceResult.Threads.Count());
}
public void TracerShouldTraceTwoMethodsOnHighestLevel()
{
ITracer tracer = new MethodTracer();
ClassWithSeveralMethods classWithSeveralMethods = new ClassWithSeveralMethods(tracer);
classWithSeveralMethods.MethodWithInnerMethods();
TraceResult traceResult = tracer.GetTraceResult();
Assert.Equal(2, traceResult.Threads[0].Methods.Count);
}
public void ShouldReturnCorrectThreadId()
{
ITracer tracer = new MethodTracer();
ClassWithSleepMethod classWithSleepMethod = new ClassWithSleepMethod(tracer);
int threadId = Thread.CurrentThread.ManagedThreadId;
classWithSleepMethod.MethodWithSleep();
TraceResult traceResult = tracer.GetTraceResult();
Assert.Equal(threadId, traceResult.Threads[0].Id);
}
public void RebuildGraph()
{
CopyPoints(originalAllPoints, allPoints);
using (MethodTracer tracer = new MethodTracer())
{
allPoints.ForEach(x =>
{
if (x.Blocked)
{
x.Blocked = !(x.Point.Equals(StartPoint) || x.Point.Equals(EndPoint));
}
});
}
}
private XElement SerializeMethodInfo(MethodTracer method)
{
var serializedMethod = new XElement("method",
new XAttribute("name", method.MethodName),
new XAttribute("time", method.ElapsedTime.ToString() + "ms"),
new XAttribute("class", method.ClassName));
if (method.Methods.Count > 0)
{
serializedMethod.Add(from innerMethod in method.Methods select SerializeMethodInfo(innerMethod));
}
return(serializedMethod);
}
private void CopyPoints(List <NNodeX> srcPoints, List <NNodeX> dstPoints)
{
using (MethodTracer tracer = new MethodTracer())
{
dstPoints.Clear();
srcPoints.ForEach(x =>
{
dstPoints.Add(new NNodeX
{
Blocked = x.Blocked,
Neighbors = x.Neighbors.ToList(),
Point = x.Point.Clone()
});
});
}
}
static void Main(string[] args)
{
ITracer methodTracer = new MethodTracer();
BackgroundTestStarter testStarter = new BackgroundTestStarter(methodTracer);
testStarter.StartTest();
TraceResult traceResult = methodTracer.GetTraceResult();
IWriter consoleWriter = new ConsoleWriter();
IWriter fileWriter = new FileWriter("out.txt");
ISerializer serializer = new JSONSerializer();
string serializedResult = serializer.Serizlize(traceResult);
consoleWriter.Write(serializedResult);
fileWriter.Write(serializedResult);
}
public void MethodInMethodTest()
{
tracer = new Tracer.Tracer();
tracer.StartTrace();
Thread.Sleep(waitTime);
SimpleTestMethod();
tracer.StopTrace();
TraceResult traceResult = tracer.GetTraceResult();
Assert.AreEqual(1, traceResult.ThreadsList.Count, countTestFailMessage);
Assert.AreEqual(TimeTest(traceResult.ThreadsList[0].Time, waitTime * 2), true, timeTestFailMessage);
Assert.AreEqual(1, traceResult.ThreadsList[0].InnerMethods.Count, countTestFailMessage);
MethodTracer methodResult = traceResult.ThreadsList[0].InnerMethods[0];
Assert.AreEqual(nameof(TracerUnitTest), methodResult.ClassName, classNameTestFailMessage);
Assert.AreEqual(nameof(MethodInMethodTest), methodResult.Name, methodNameTestFailMessage);
Assert.AreEqual(TimeTest(methodResult.Time, waitTime), true, timeTestFailMessage);
Assert.AreEqual(1, methodResult.InnerMethods.Count, countTestFailMessage);
MethodTracer innerMethodResult = methodResult.InnerMethods[0];
Assert.AreEqual(nameof(TracerUnitTest), innerMethodResult.ClassName, classNameTestFailMessage);
Assert.AreEqual(nameof(SimpleTestMethod), innerMethodResult.Name, methodNameTestFailMessage);
Assert.AreEqual(TimeTest(innerMethodResult.Time, waitTime), true, timeTestFailMessage);
}
private StringBuilder GetInfo(MethodTracer info, StringBuilder builder = null)
{
if (builder == null)
{
builder = new StringBuilder();
}
else
{
builder.Append("\r\n");
}
builder.AppendLine($"TraceID:{info.TraceID} ");
builder.AppendLine($"MethodID:{info.MethodID} ");
builder.AppendLine($"MethodName:{info.MethodName} ");
builder.AppendLine($"EventID:{info.EventID} ");
builder.AppendLine($"MethodEventID:{info.MethodEventID} ");
builder.AppendLine($"PreMethodEventID:{info.PreMethodEventID} ");
builder.AppendLine($"FileName:{info.FileName} LineNumber:{info.LineNumber} ");
builder.AppendLine($"NodeID:{info.NodeID} ");
builder.AppendLine($"TimeStamp:{info.TimeStamp} ");
builder.AppendLine($"Time:{new DateTime(info.TimeStamp):yyyy-MM-dd HH:mm:ss:fff} ");
builder.AppendLine($"CustomData:{System.Text.Json.JsonSerializer.Serialize(info.CustomData)} ");
builder.AppendLine();
return(builder);
}
private void SetUp()
{
_methodTracer = new MethodTracer();
}
private NNodeX Process(NPoint point)
{
using (MethodTracer tracer = new MethodTracer())
{
int level = 0;
List <NNodeX> masterList = new List <NNodeX>();
List <NNodeX> neighbours = new List <NNodeX>();
List <NNodeX> tempList = new List <NNodeX>();
int id = PointToId(point);
if (id < 0 || id >= allPoints.Count)
{
return(null);
}
NNodeX startRoot = allPoints[id];
startRoot.Level = level;
startRoot.Visited = true;
List <NNodeX> currNodes = new List <NNodeX> {
startRoot
};
Connector.StartNode = startRoot;
if (startRoot.Point.Equals(EndPoint))
{
return(startRoot);
}
do
{
level++;
neighbours.Clear();
foreach (NNodeX currNode in currNodes)
{
NNodeX node = null;
foreach (int x in currNode.Neighbors)
{
if (allPoints[x].Point.Equals(EndPoint))
{
node = allPoints[x];
break;
}
}
if (node != null)
{
node.Parent = currNode;
return(node);
}
foreach (int x in currNode.Neighbors)
{
NNodeX nChild = allPoints[x];
if (!nChild.Blocked && !nChild.Visited)
{
nChild.Visited = true;
nChild.Parent = currNode;
neighbours.Add(nChild);
}
}
}
currNodes.Clear();
currNodes.AddRange(neighbours);
} while (neighbours.Count > 0);
return(null);
}
}
