public void Init()
{
filesystem = new Mock <IFilesystem>();
processHandler = new ProcessHandlerDouble();
analysisResult = new SDResult();
var coredump = new Mock <IFileInfo>();
coredump.Setup(c => c.FullName).Returns(PATH + "dump.core");
analysis = new GdbAnalyzer(filesystem.Object, processHandler, coredump.Object, analysisResult);
this.analysisResult.ThreadInformation = new Dictionary <uint, SDThread>();
SDThread thread = new SDThread();
var frames = new List <SDCombinedStackFrame> {
new SDCDCombinedStackFrame("module", "method", 0, 0, 0, 0, 0, null)
};
thread.StackTrace = new SDCombinedStackTrace(frames);
this.analysisResult.ThreadInformation.Add(0, thread);
SDCDSystemContext context = new SDCDSystemContext()
{
FileName = PATH + "my-executable"
};
analysisResult.SystemContext = context;
}
public override void AnalyzeFrame(SDThread thread, SDCombinedStackFrame frame)
{
if (frame.MethodName == null)
{
return;
}
if (ContainsAny(frame.MethodName, "Thread::WaitSuspendEvents"))
{
frame.Tags.Add(SDTag.ClrThreadSuspend);
thread.Tags.Add(SDTag.ClrThreadSuspend);
}
if (ContainsAny(frame.MethodName, "GCHeap::WaitUntilGCComplete") || ContainsAny(frame.MethodName, "SVR::gc_heap::wait_for_gc_done"))
{
frame.Tags.Add(SDTag.ClrWaitForGc);
thread.Tags.Add(SDTag.ClrWaitForGc);
}
if (ContainsAny(frame.MethodName, "gc_heap::gc_thread_stub"))
{
frame.Tags.Add(SDTag.ClrGcThread);
thread.Tags.Add(SDTag.ClrGcThread);
}
if (ContainsAny(frame.MethodName, "_CrtDbgReport"))
{
frame.Tags.Add(SDTag.AssertionErrorTag);
thread.Tags.Add(SDTag.AssertionErrorTag);
}
}
public override void AnalyzeFrame(SDThread thread, SDCombinedStackFrame frame)
{
if (frame.MethodName == null)
{
return;
}
AddTagIfFrameContains(thread, frame, x => ContainsAny(frame.MethodName, "exception"), SDTag.ExceptionInStackTag);
bool hasAddedSpecialAgentTag = false;
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsPhpAgentModule, SDTag.DynatracePhpAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsJavaAgentModule, SDTag.DynatraceJavaAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsDotnetAgentModule, SDTag.DynatraceDotNetAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsProcessAgentModule, SDTag.DynatraceProcessAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsIisAgentModule, SDTag.DynatraceIisAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsLogAgentModule, SDTag.DynatraceLogAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsOsAgentModule, SDTag.DynatraceOsAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsPluginAgentModule, SDTag.DynatracePluginAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsNetworkAgentModule, SDTag.DynatraceNetworkAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsNginxAgentModule, SDTag.DynatraceNginxAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsVarnishAgentModule, SDTag.DynatraceVarnishAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsWatchdogFrame, SDTag.DynatraceWatchdogTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsNodeAgentModule, SDTag.DynatraceNodeAgentTag);
hasAddedSpecialAgentTag |= AddTagIfFrameContains(thread, frame, ContainsAgentLoaderModule, SDTag.DynatraceAgentLoaderTag);
if (!hasAddedSpecialAgentTag)
{
// if no special agent has been detected, add generic dynatrace agent tag
AddTagIfFrameContains(thread, frame, ContainsDynatraceModule, SDTag.DynatraceAgentTag);
}
}
private void UnwindCurrentThread(SDCDSystemContext context, SDThread thread)
{
var frames = new List <SDCombinedStackFrame>();
ulong ip, oldIp = 0, sp, oldSp = 0, offset, oldOffset = 0;
string procName, oldProcName = null;
int nFrames = 0;
do
{
ip = getInstructionPointer();
sp = getStackPointer();
procName = getProcedureName();
offset = getProcedureOffset();
if (oldProcName != null)
{
frames.Add(new SDCDCombinedStackFrame("", oldProcName, oldOffset, oldIp, oldSp, ip, 0, null));
}
oldIp = ip;
oldSp = sp;
oldOffset = offset;
oldProcName = procName;
} while (!step() && ++nFrames < MAX_FRAMES);
thread.StackTrace = new SDCombinedStackTrace(frames);
}
public override void AnalyzeThread(SDThread thread)
{
if (thread.LastException != null)
{
thread.Tags.Add(SDTag.ManagedExceptionTag);
}
}
public override void AnalyzeFrame(SDThread thread, SDCombinedStackFrame frame)
{
if (IsNativeExceptionMethodFrame(frame))
{
frame.Tags.Add(SDTag.NativeExceptionTag);
thread.Tags.Add(SDTag.NativeExceptionTag);
}
}
private void PrepareSampleThread(ulong instrPtr)
{
result.ThreadInformation = new Dictionary <uint, SDThread>();
SDThread thread = new SDThread(1);
IList <SDCombinedStackFrame> stackFrames = new List <SDCombinedStackFrame>();
stackFrames.Add(new SDCombinedStackFrame(StackFrameType.Native, DEFAULT_MODULE_NAME, DEFAULT_METHOD_NAME, 42, instrPtr, 42, 42, null, 42, null));
thread.StackTrace = new SDCombinedStackTrace(stackFrames);
result.ThreadInformation.Add(1, thread);
}
public override void AnalyzeFrame(SDThread thread, SDCombinedStackFrame frame)
{
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "_purecall", SDTag.PureCallTag);
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "abort", SDTag.AbortTag);
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "__CxxCallCatchBlock", SDTag.ExceptionCatchTag);
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "RcCosolidateFrames", SDTag.ExceptionCatchTag);
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "RtlRaiseException", SDTag.NativeExceptionTag);
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "RtlReportException", SDTag.NativeExceptionTag);
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "__report_gsfailure", SDTag.BufferOverrunTag);
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "__chkstk", SDTag.StackOverflowTag);
}
/// <summary>
/// if <paramref name="func"/> returns true, set <paramref name="tag"/> on frame and thread
/// </summary>
private bool AddFrameAndThreadTagIf(SDThread thread, SDCombinedStackFrame frame, Func <bool> func, SDTag tag)
{
if (!func())
{
return(false);
}
frame.Tags.Add(tag);
thread.Tags.Add(tag);
return(true);
}
/// <summary>
/// if <paramref name="func"/> returns true, set <paramref name="tag"/> on frame and thread
/// </summary>
private bool AddTagIfFrameContains(SDThread thread, SDCombinedStackFrame frame, Func <string, bool> func, SDTag tag)
{
if (!func(frame.ModuleName + frame.Type.ToString() + frame.MethodName))
{
return(false);
}
frame.Tags.Add(tag);
thread.Tags.Add(tag);
return(true);
}
public override void AnalyzeFrame(SDThread thread, SDCombinedStackFrame frame)
{
if (IsExceptionFrame(frame))
{
frame.Tags.Add(SDTag.ExceptionInStackTag);
thread.Tags.Add(SDTag.ExceptionInStackTag);
}
if (IsDynatraceAgentFrame(frame))
{
frame.Tags.Add(SDTag.DynatraceAgentTag);
thread.Tags.Add(SDTag.DynatraceAgentTag);
}
}
public static string ToText(this SDThread thread)
{
if (thread == null)
{
return(string.Empty);
}
var sb = new StringBuilder();
foreach (var frame in thread.StackTrace)
{
sb.AppendLine(frame.ToString());
}
return(sb.ToString());
}
public void ThreadSerializationTest()
{
ThreadAnalyzer analyzer = new ThreadAnalyzer(context);
Assert.IsNotNull(analyzer.threads);
foreach (var key in analyzer.threads.Keys)
{
SDThread t = analyzer.threads[key];
Assert.AreEqual(t.OsId, key); // should be the same, as threads are inserted in the dictionary with their OS id
string json = t.StackTrace.SerializeToJSON();
SDCombinedStackTrace trace = JsonConvert.DeserializeObject <SDCombinedStackTrace>(json);
Assert.IsNotNull(trace);
Assert.IsTrue(Enumerable.SequenceEqual(t.StackTrace, trace));
}
}
public void PrintStackTrace(SDThread thread)
{
context.WriteInfo("Thread CLR ID: {0}, OS ID: {1:X}, State: {2}, IsThreadPoolThread: {3}, {4}", thread.EngineId, thread.OsId, thread.State, thread.IsThreadPoolThread, TagAnalyzer.TagsAsString("Tags: ", thread.Tags));
foreach (SDCombinedStackFrame frame in thread.StackTrace)
{
if (frame.Type == StackFrameType.Special)
{
context.WriteLine("{0,-10} {1,-20:x16} {2}", "Special", frame.InstructionPointer, "[" + frame.MethodName + "]");
}
else
{
context.WriteLine("{0,-10} {1,-20:x16} {2}!{3}+0x{4:x}",
frame.Type,
frame.InstructionPointer,
frame.ModuleName,
frame.MethodName,
frame.OffsetInMethod);
Console.ResetColor();
}
}
context.WriteInfo("-- end call stack (thread {0}) --\n", thread.OsId);
}
/// <summary>
/// Inits the thread dictionary with OS ID and engine ID of every thread,
/// and also refs managed thread if there is one for each thread in the process dump
/// </summary>
private void InitAllThreadIds()
{
// get amount of threads in the process
Utility.CheckHRESULT(((IDebugSystemObjects)this.debugClient).GetNumberThreads(out numberOfThreads));
for (uint i = 0; i < numberOfThreads; i++)
{
var engineThreadIds = new uint[1]; // has to be array, see IDebugSystemObjects.GetThreadIdsByIndex
var osThreadIds = new uint[1]; // same here
// get the engine id(s) and also the os id(s) of each thread
Utility.CheckHRESULT(((IDebugSystemObjects)this.debugClient).GetThreadIdsByIndex(i, 1, engineThreadIds, osThreadIds));
// create new SDThread object and add it to the dictionary
var t = new SDThread(i);
t.OsId = osThreadIds[0];
t.EngineId = engineThreadIds[0];
ClrThread managedThread = null;
if (context.Runtime != null)
{
managedThread = context.Runtime.Threads.FirstOrDefault(thread => thread.OSThreadId == t.OsId);
if (managedThread != null)
{
t.IsManagedThread = true;
t.ManagedThreadId = managedThread.ManagedThreadId;
t.State = managedThread.SpecialDescription();
t.IsThreadPoolThread = managedThread.IsThreadPoolThread();
}
else
{
t.IsManagedThread = false;
}
}
this.threads.Add(t.OsId, t);
}
}
public void ThreadAnalyzerStacktraceTest()
{
ThreadAnalyzer analyzer = new ThreadAnalyzer(context);
// pick any thread stacktrace, in this case take thread 932, os id = 27484
SDThread thread = analyzer.threads[27484];
Assert.IsNotNull(thread);
IList <string> trace = ReadTraceFromThread932();
Assert.AreEqual(trace.Count, thread.StackTrace.Count);
for (int i = 0; i < trace.Count; i++)
{
var values = trace[i].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (values.Length > 0)
{
string method = values[2]; // method name after SP and IP
StringAssert.Equals(thread.StackTrace[i].MethodName, method);
}
}
}
public override void AnalyzeFrame(SDThread thread, SDCombinedStackFrame frame)
{
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "_purecall", SDTag.PureCallTag);
AddFrameAndThreadTagIf(thread, frame, () => frame.MethodName == "abort", SDTag.AbortTag);
}
public async Task <string> GetMessage(DumpMetainfo dumpInfo)
{
var model = new SlackMessageViewModel();
var res = dumpRepo.GetResult(dumpInfo.BundleId, dumpInfo.DumpId, out string error);
var engine = new EngineFactory().ForEmbeddedResources(typeof(SlackMessageViewModel));
model.TopProperties.Add(dumpInfo.DumpType == DumpType.WindowsDump ? "Windows" : "Linux");
model.DumpFilename = Path.GetFileName(dumpInfo.DumpFileName);
model.Url = $"{superDumpUrl}/Home/Report?bundleId={dumpInfo.BundleId}&dumpId={dumpInfo.DumpId}";
if (res != null)
{
model.TopProperties.Add(res.SystemContext.ProcessArchitecture);
if (res.IsManagedProcess)
{
model.TopProperties.Add(".NET");
}
if (res.SystemContext.Modules.Any(x => x.FileName.Contains("jvm.dll")))
{
model.TopProperties.Add("Java");
}
if (res.SystemContext.Modules.Any(x => x.FileName.Contains("jvm.so")))
{
model.TopProperties.Add("Java");
}
if (res.SystemContext.Modules.Any(x => x.FileName.Contains("iiscore.dll")))
{
model.TopProperties.Add("IIS");
}
if (res.SystemContext.Modules.Any(x => x.FileName.Contains("nginx.so")))
{
model.TopProperties.Add("NGINX");
}
if (res.SystemContext.Modules.Any(x => x.FileName.Contains("httpd/modules")))
{
model.TopProperties.Add("Apache");
}
if (res.SystemContext.Modules.Any(x => x.FileName.Contains("node.exe")))
{
model.TopProperties.Add("Node.js");
}
var agentModules = res.SystemContext.Modules.Where(x => x.Tags.Any(t => t.Equals(SDTag.DynatraceAgentTag))).Select(m => m.ToString());
model.AgentModules = agentModules.ToList();
model.NumManagedExceptions = res.ThreadInformation.Count(x => x.Value.Tags.Any(t => t.Equals(SDTag.ManagedExceptionTag)));
model.NumNativeExceptions = res.ThreadInformation.Count(x => x.Value.Tags.Any(t => t.Equals(SDTag.NativeExceptionTag)));
model.NumAssertErrors = res.ThreadInformation.Count(x => x.Value.Tags.Any(t => t.Equals(SDTag.AssertionErrorTag)));
SDThread managedExceptionThread = res.ThreadInformation.Values.FirstOrDefault(x => x.Tags.Any(t => t.Equals(SDTag.ManagedExceptionTag)));
SDClrException clrException = managedExceptionThread?.LastException;
if (clrException != null)
{
model.TopException = clrException.Type;
model.Stacktrace = clrException.StackTrace.ToString();
}
if (res.LastEvent != null && !res.LastEvent.Description.Contains("Break instruction")) // break instruction events are useless
{
model.LastEvent = $"{res.LastEvent.Type}: {res.LastEvent.Description}";
}
}
return(await engine.CompileRenderAsync("SlackMessage", model));
}
public virtual void AnalyzeFrame(SDThread thread, SDCombinedStackFrame frame)
{
}
private Dictionary <uint, SDThread> UnwindThreads(SDCDSystemContext context)
{
var threads = new Dictionary <uint, SDThread>();
int nThreads = getNumberOfThreads();
for (uint i = 0; i < nThreads; i++)
{
selectThread(i);
SDThread thread = new SDThread()
{
EngineId = i,
OsId = i,
Index = i
};
UnwindCurrentThread(context, thread);
threads.Add(i, thread);
}
bool foundLastExecuted = false;
for (int i = 0; i < nThreads; i++)
{
int signal = getSignalNumber(i);
if (signal == -1)
{
continue;
}
if (signal < 32 && signal != 19)
{
if (foundLastExecuted)
{
Console.WriteLine("Already found the last executed thread which was: " + analysisResult.LastExecutedThread + ". New one is " + i);
}
foundLastExecuted = true;
analysisResult.LastExecutedThread = (uint)i;
analysisResult.LastEvent = new SDLastEvent()
{
ThreadId = (uint)i,
Type = signal.ToString(),
Description = SignalNoToCode(signal)
};
if (signal == 4 || signal == 8)
{
analysisResult.LastEvent.Description += ": Faulty instruction at address " + getSignalAddress(i);
}
else if (signal == 11)
{
analysisResult.LastEvent.Description += ": Invalid memory reference to address 0x" + getSignalAddress(i).ToString("X");
}
else
{
int error = getSignalErrorNo(i);
if (error != 0)
{
analysisResult.LastEvent.Description += " (error number " + error + ")";
}
}
}
}
return(threads);
}
public virtual void AnalyzeThread(SDThread thread)
{
}
