public void AverageCentreOneValue(int percentageToKeep, int expected, string values)
{
var data = values.Split(",").Select(int.Parse).ToList();
var result = TraceProcessor.AverageCentre(data, percentageToKeep);
Assert.AreEqual(expected, result);
}
private static int Main(string[] args)
{
if (args.Length != 1)
{
Console.Error.WriteLine("Usage CheckForAppCrash <trace.etl>");
return(-1);
}
string tracePath = args[0];
using (ITraceProcessor trace = TraceProcessor.Create(tracePath))
{
IPendingResult <IProcessDataSource> pendingProcesses = trace.UseProcesses();
trace.Process();
IProcessDataSource processData = pendingProcesses.Result;
foreach (IProcess process in processData.Processes)
{
if (string.Equals("werfault.exe", process.ImageName, StringComparison.OrdinalIgnoreCase))
{
return(1);
}
}
}
return(0);
}
private static void Process(string path)
{
try
{
if (string.IsNullOrEmpty(path))
{
Console.Error.WriteLine("ETL file location not provided...");
return;
}
using (ITraceProcessor trace = TraceProcessor.Create(path))
{
IPendingResult <IProcessDataSource> pendingProcessData = trace.UseProcesses();
trace.Process();
IProcessDataSource processData = pendingProcessData.Result;
foreach (IProcess process in processData.Processes)
{
log.Info(process.CommandLine);
}
}
}
catch (Exception ex)
{
Console.WriteLine($"An error occured while processing. {ex}");
throw ex;
}
}
public void CalculateUsingNull()
{
// Act
Assert.Throws <ArgumentNullException>(() => TraceProcessor.CalculateDelta(null, new List <int>()));
Assert.Throws <ArgumentNullException>(() => TraceProcessor.CalculateDelta(new List <int>(), null));
Assert.Throws <ArgumentNullException>(() => TraceProcessor.CalculateDelta(null, null));
}
public void AdjustBadSteadyStateToGoodStateState(string bad, string expected)
{
var data = bad.Split(",").Select(int.Parse).ToList();
var result = TraceProcessor.AdjustBadSteadyStateToGoodStateState(1000, data);
Assert.AreEqual(expected, string.Join(',', result));
}
public void SetRiseLocationToZero(int rise, string values, string expected)
{
var data = values.Split(",").Select(int.Parse).ToList();
var result = TraceProcessor.SetRiseLocationToColumnZero(data, rise);
Assert.AreEqual(expected, string.Join(',', result));
}
public void FindRiseColumn(int expected, int rise, string values)
{
var data = values.Split(",").Select(int.Parse).ToList();
var result = TraceProcessor.FindRiseColumn(data, rise);
Assert.AreEqual(expected, data[result]);
Console.WriteLine("Column {0}", result);
}
static void Main(string[] args)
{
bool showCPUUsage = false;
string traceName = "";
foreach (string arg in args)
{
if (arg == "-c" || arg == "--cpuusage")
{
showCPUUsage = true;
}
else if (traceName.Length == 0)
{
traceName = arg;
}
else
{
Console.Error.WriteLine("error: unrecognized arguments: {0}", arg);
return;
}
}
if (traceName.Length == 0)
{
Console.Error.WriteLine("usage: IdentifyChromeProcesses.exe [-c] trace");
Console.Error.WriteLine("error: too few arguments");
return;
}
if (!File.Exists(traceName))
{
Console.Error.WriteLine("File '{0}' does not exist.", traceName);
return;
}
try
{
using (ITraceProcessor trace = TraceProcessor.Create(traceName))
ProcessTrace(trace, showCPUUsage, false);
}
catch (System.InvalidOperationException e)
{
// Note that wpaexporter doesn't seem to have a way to handle this,
// which is one advantage of TraceProcessing. Note that traces with
// lost events are "corrupt" in some sense so the results will be
// unpredictable.
Console.WriteLine(e.Message);
Console.WriteLine("Trying again with AllowLostEvents and AllowTimeInversion specified. Results may be less reliable.");
Console.WriteLine();
var settings = new TraceProcessorSettings();
settings.AllowLostEvents = true;
settings.AllowTimeInversion = true;
using (ITraceProcessor trace = TraceProcessor.Create(traceName, settings))
ProcessTrace(trace, showCPUUsage, true);
}
}
private void DeleteFile(string filename)
{
var folder = TraceProcessor.GetCurrentFolder();
var file = Path.Combine(folder, filename);
if (File.Exists(file))
{
File.Delete(file);
}
}
public List <double> ReadDeltaFile()
{
var folder = TraceProcessor.GetCurrentFolder();
var filename = Path.Combine(folder, Constants.GoodTraceFilename);
return(File.ReadAllText(filename)
.Split(',')
.Select(double.Parse)
.ToList());
}
static void Main(string[] args)
{
if (args.Length != 3)
{
Console.Error.WriteLine("Usage: GetCpuSampleDuration.exe <trace.etl> <imageName> <functionName>");
return;
}
string tracePath = args[0];
string imageName = args[1];
string functionName = args[2];
Dictionary <string, Duration> matchDurationByCommandLine = new Dictionary <string, Duration>();
using (ITraceProcessor trace = TraceProcessor.Create(tracePath))
{
IPendingResult <ISymbolDataSource> pendingSymbolData = trace.UseSymbols();
IPendingResult <ICpuSampleDataSource> pendingCpuSamplingData = trace.UseCpuSamplingData();
trace.Process();
ISymbolDataSource symbolData = pendingSymbolData.Result;
ICpuSampleDataSource cpuSamplingData = pendingCpuSamplingData.Result;
symbolData.LoadSymbolsForConsoleAsync(SymCachePath.Automatic, SymbolPath.Automatic).GetAwaiter().GetResult();
Console.WriteLine();
IThreadStackPattern pattern = AnalyzerThreadStackPattern.Parse($"{imageName}!{functionName}");
foreach (ICpuSample sample in cpuSamplingData.Samples)
{
if (sample.IsExecutingDeferredProcedureCall == true || sample.IsExecutingInterruptServicingRoutine == true)
{
continue;
}
if (sample.Stack != null && sample.Stack.Matches(pattern))
{
string commandLine = sample.Process.CommandLine;
if (!matchDurationByCommandLine.ContainsKey(commandLine))
{
matchDurationByCommandLine.Add(commandLine, Duration.Zero);
}
matchDurationByCommandLine[commandLine] += sample.Weight;
}
}
}
foreach (string commandLine in matchDurationByCommandLine.Keys)
{
Console.WriteLine($"{commandLine}: {matchDurationByCommandLine[commandLine]}");
}
}
private void WriteFile <T>(string filename, List <T> data)
{
var folder = TraceProcessor.GetCurrentFolder();
var output = Path.Combine(folder, filename);
Console.WriteLine($"output: {output}");
var text = string.Join(',', data);
File.WriteAllText(output, text);
}
static void Run(string tracePath)
{
using (ITraceProcessor trace = TraceProcessor.Create(tracePath))
{
IPendingResult <IProcessDataSource> pendingProcessData = trace.UseProcesses();
trace.Process();
IProcessDataSource processData = pendingProcessData.Result;
Console.WriteLine(processData.Processes.Count);
}
}
private static IReadOnlyList <string> GetServices(string tracePath)
{
using (ITraceProcessor trace = TraceProcessor.Create(tracePath))
{
IPendingResult <IServiceDataSource> pendingServices = trace.UseServices();
trace.Process();
IServiceDataSource serviceData = pendingServices.Result;
return(serviceData.Services.Select(s => Cleanup(s.Name)).ToArray());
}
}
public List <int> ReadGoodFile()
{
var folder = TraceProcessor.GetCurrentFolder();
var filename = Path.Combine(folder, Constants.GoodTraceFilename);
var result = _reader.ReadInput(filename);
if (!result.success)
{
Console.WriteLine($"Unable to read in good alpha file {filename}");
return(null);
}
return(result.data[0]);
}
public void MinColumnCount()
{
var good = new List <int> {
1, 2, 3, 4
};
var bad = new List <int> {
5, 6
};
var result = TraceProcessor.CalculateDelta(good, bad);
Assert.IsNotNull(result);
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
}
public void CalculateDeltaUnevenData()
{
var good = new List <int> {
3000, 3000, 3000
};
var bad = new List <int> {
2900, 3000, 3111
};
var result = TraceProcessor.CalculateDelta(good, bad);
Assert.NotNull(result);
Assert.AreEqual(good.Count, result.Count);
Assert.AreEqual(3000.0 / 2900.0, result[0]);
Assert.AreEqual(1.0, result[1]);
Assert.AreEqual(3000.0 / 3111.0, result[2]);
}
private void GatherTraceData()
{
using (ITraceProcessor trace = TraceProcessor.Create(EtlPath))
{
IPendingResult <IProcessDataSource> pendingProcessData = trace.UseProcesses();
IPendingResult <IThreadDataSource> pendingThreadData = trace.UseThreads();
IPendingResult <ICpuSampleDataSource> pendingCpuSampleData = trace.UseCpuSamplingData();
IPendingResult <ICpuSchedulingDataSource> pendingCpuSchedulingData = trace.UseCpuSchedulingData();
trace.Process();
GatherProcessData(pendingProcessData.Result);
GatherThreadData(pendingThreadData.Result);
GatherCpuSampleData(pendingCpuSampleData.Result);
GatherCpuSchedulingData(pendingCpuSchedulingData.Result);
}
}
public void TransposeTest()
{
// Arrange
var data = new List <List <int> >
{
new List <int> {
3, 1, 2
},
new List <int> {
600, 200, 300
}
};
// Act
var result = TraceProcessor.Transpose(data);
foreach (var y in result)
{
foreach (var x in y)
{
Console.Write($"{x}, ");
}
Console.WriteLine();
}
// Assert
Assert.AreEqual(3, result.Count);
var row = result[0];
Assert.AreEqual(2, row.Count);
Assert.AreEqual(3, row[0]);
Assert.AreEqual(600, row[1]);
row = result[1];
Assert.AreEqual(2, row.Count);
Assert.AreEqual(1, row[0]);
Assert.AreEqual(200, row[1]);
row = result[2];
Assert.AreEqual(2, row.Count);
Assert.AreEqual(2, row[0]);
Assert.AreEqual(300, row[1]);
}
static void Main(string[] args)
{
if (args.Length != 1 || string.IsNullOrWhiteSpace(args[0]))
{
Console.Error.WriteLine("Usage: <trace.etl>");
return;
}
using (var trace = TraceProcessor.Create(args[0]))
{
var pendingProcessData = trace.UseProcesses();
trace.Process();
var processData = pendingProcessData.Result;
foreach (var process in processData.Processes)
{
Console.WriteLine(process.CommandLine);
}
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.Error.WriteLine("Usage: <trace.etl>");
return;
}
using (ITraceProcessor trace = TraceProcessor.Create(args[0]))
{
IPendingResult <IProcessDataSource> pendingProcessData = trace.UseProcesses();
trace.Process();
IProcessDataSource processData = pendingProcessData.Result;
foreach (IProcess process in processData.Processes)
{
Console.WriteLine(process.CommandLine);
}
}
}
public static int Main(string[] args)
{
if (args.Length != 1)
{
Console.Error.WriteLine("Usage: FindZombieProcess.exe <trace.etl>");
return(1);
}
string tracePath = args[0];
TraceProcessorSettings settings = new TraceProcessorSettings {
AllowLostEvents = true
};
using (ITraceProcessor trace = TraceProcessor.Create(tracePath, settings))
{
IPendingResult <IHandleDataSource> pendingHandleData = trace.UseHandles();
IPendingResult <ISymbolDataSource> pendingSymbolData = trace.UseSymbols();
trace.Process();
IHandleDataSource handleData = pendingHandleData.Result;
ISymbolDataSource symbolData = pendingSymbolData.Result;
symbolData.LoadSymbolsForConsoleAsync(SymCachePath.Automatic, SymbolPath.Automatic).GetAwaiter().GetResult();
foreach (IProcessHandle processHandle in handleData.ProcessHandles)
{
// Zombie processes are processes which have exited but which still have a running process holding a handle to them
if (processHandle.Process != null && !processHandle.CloseTime.HasValue &&
processHandle.Process.ExitTime.HasValue)
{
string owningProcessName = processHandle.Owner?.ImageName ?? "Unknown";
string targetProcessName = processHandle.Process?.ImageName ?? "Unknown";
Console.WriteLine($"Owning process: {owningProcessName} has handle to: {targetProcessName}");
}
}
return(0);
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.Error.WriteLine("Usage: ListImages.exe <trace.etl>");
return;
}
string tracePath = args[0];
using (ITraceProcessor trace = TraceProcessor.Create(tracePath))
{
IPendingResult <IProcessDataSource> pendingProcessData = trace.UseProcesses();
trace.Process();
IProcessDataSource processData = pendingProcessData.Result;
foreach (IProcess process in processData.Processes)
{
foreach (IImage image in process.Images)
{
DataSize ImageSize = image.Size;
long TimeDataStamp = image.Timestamp;
string OrigFileName = image.OriginalFileName;
string FileDescription = image.FileDescription;
string FileVersion = image.FileVersion;
Version BinFileVersion = image.FileVersionNumber;
CultureInfo VerLanguage = image.Locale;
string ProductName = image.ProductName;
string CompanyName = image.CompanyName;
string ProductVersion = image.ProductVersion;
string FileId = image.CompatibilityFileId;
string ProgramId = image.CompatibilityProgramId;
}
}
}
}
static Timestamp GetBootTime(string tracePath)
{
Timestamp result = Timestamp.Zero;
using (ITraceProcessor trace = TraceProcessor.Create(tracePath))
{
// Microsoft-Windows-Shell-Core
trace.Use(new Guid[] { new Guid("30336ed4-e327-447c-9de0-51b652c86108") }, e =>
{
// PerfTrack_Explorer_ExplorerStartToDesktopReady
if (e.Id != 27231)
{
return;
}
result = e.Timestamp;
});
trace.Process();
}
return(result);
}
private static IReadOnlyDictionary <PageKey, uint> GetResidentSetPageCounts(string tracePath,
Timestamp startTime, Timestamp stopTime)
{
using (ITraceProcessor trace = TraceProcessor.Create(tracePath))
{
IPendingResult <IResidentSetDataSource> pendingResidentSet = trace.UseResidentSetData();
trace.Process();
IResidentSetDataSource residentSetData = pendingResidentSet.Result;
Dictionary <PageKey, uint> pageCounts = new Dictionary <PageKey, uint>();
foreach (IResidentSetSnapshot snapshot in residentSetData.Snapshots)
{
if (snapshot.Timestamp < startTime || snapshot.Timestamp > stopTime)
{
continue;
}
foreach (IResidentSetPage page in snapshot.Pages)
{
PageKey key = new PageKey(snapshot.Timestamp, page.MemoryManagerListType, page.Priority);
if (!pageCounts.ContainsKey(key))
{
pageCounts.Add(key, 0);
}
++pageCounts[key];
}
}
return(pageCounts);
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Specify the name of one trace to be summarized.");
return;
}
var traceName = args[0];
if (!File.Exists(traceName))
{
Console.Error.WriteLine("File '{0}' does not exist.", traceName);
return;
}
var settings = new TraceProcessorSettings
{
// Don't print a setup message on first run.
SuppressFirstTimeSetupMessage = true
};
using (ITraceProcessor trace = TraceProcessor.Create(traceName, settings))
{
// Get process details, including command lines.
var pendingProcessData = trace.UseProcesses();
// Get CPU performance counters, on every context switch.
var pendingCounterData = trace.UseProcessorCounters();
trace.Process();
var processData = pendingProcessData.Result;
var counterData = pendingCounterData.Result;
var countersByProcess = FindInterestingProcesses(processData);
// Accumulate data for all of the interesting processes.
foreach (var entry in counterData.ContextSwitchCounterDeltas)
{
// This sometimes happens - handle it.
if (entry.Process == null)
{
continue;
}
Counters last;
if (!countersByProcess.TryGetValue(entry.Process, out last))
{
continue;
}
// Accumulate counter values and execution time.
foreach (var key in entry.RawCounterDeltas.Keys)
{
last.counters.TryGetValue(key, out ulong lastCount);
lastCount += entry.RawCounterDeltas[key];
last.counters[key] = lastCount;
}
last.runTime_ns += (entry.StopTime - entry.StartTime).Nanoseconds;
last.contextSwitches += 1;
countersByProcess[entry.Process] = last;
}
// Sort the data by CPU time and print it.
var sortedCounterData = new List <KeyValuePair <IProcess, Counters> >(countersByProcess);
sortedCounterData.Sort((x, y) => y.Value.runTime_ns.CompareTo(x.Value.runTime_ns));
bool printHeader = true;
foreach (var entry in sortedCounterData)
{
if (printHeader)
{
Console.Write("{0,-29} - CPU time (s) - context switches", "Image name");
foreach (var counterName in entry.Value.counters.Keys)
{
int fieldWidth = Math.Max(13, counterName.Length);
Console.Write(", {0}", counterName.PadLeft(fieldWidth));
}
Console.WriteLine();
printHeader = false;
}
// Arbitrary cutoff for what is "interesting"
if (entry.Value.runTime_ns < 100 * 1000 * 1000)
{
continue;
}
Console.Write("{0,-29} - {1,8:0.00} - {2,16}", entry.Value.description,
entry.Value.runTime_ns / 1e9, entry.Value.contextSwitches);
foreach (var counterName in entry.Value.counters.Keys)
{
int fieldWidth = Math.Max(13, counterName.Length);
Console.Write(", {0}",
entry.Value.counters[counterName].ToString().PadLeft(fieldWidth));
}
Console.WriteLine();
}
}
}
static void RunWithOptions(Options opts)
{
using (ITraceProcessor trace = TraceProcessor.Create(opts.etlFileName))
{
IPendingResult <ICpuSampleDataSource> pendingCpuSampleData = trace.UseCpuSamplingData();
IPendingResult <ISymbolDataSource> pendingSymbolData = trace.UseSymbols();
trace.Process();
ISymbolDataSource symbolData = pendingSymbolData.Result;
ICpuSampleDataSource cpuSampleData = pendingCpuSampleData.Result;
var symbolProgress = new Progress <SymbolLoadingProgress>(progress =>
{
Console.Write("\r{0:P} {1} of {2} symbols processed ({3} loaded)",
(double)progress.ImagesProcessed / progress.ImagesTotal,
progress.ImagesProcessed,
progress.ImagesTotal,
progress.ImagesLoaded);
});
symbolData.LoadSymbolsAsync(
SymCachePath.Automatic, SymbolPath.Automatic, symbolProgress)
.GetAwaiter().GetResult();
Console.WriteLine();
var profileWriter = new ProfileWriter(opts.etlFileName,
opts.includeInlinedFunctions,
opts.includeProcessAndThreadIds,
opts.stripSourceFileNamePrefix);
var timeStart = opts.timeStart ?? 0;
var timeEnd = opts.timeEnd ?? decimal.MaxValue;
var exportAllProcesses = opts.processFilter == "*";
var processFilterSet = new HashSet <string>(
opts.processFilter.Trim().Split(",", StringSplitOptions.RemoveEmptyEntries));
for (int i = 0; i < cpuSampleData.Samples.Count; i++)
{
if (i % 100 == 0)
{
Console.Write("\r{0:P} {1} of {2} samples processed",
(double)i / cpuSampleData.Samples.Count, i, cpuSampleData.Samples.Count);
}
var cpuSample = cpuSampleData.Samples[i];
if ((cpuSample.IsExecutingDeferredProcedureCall ?? false) ||
(cpuSample.IsExecutingInterruptServicingRoutine ?? false))
{
continue;
}
if (!exportAllProcesses)
{
var processImage = cpuSample.Process.Images
.FirstOrDefault(image => image.FileName == cpuSample.Process.ImageName);
string imagePath = processImage?.Path ?? cpuSample.Process.ImageName;
if (!processFilterSet.Any(filter => imagePath.Contains(filter.Replace("/", "\\"))))
{
continue;
}
}
var timestamp = cpuSample.Timestamp.RelativeTimestamp.TotalSeconds;
if (timestamp < timeStart || timestamp > timeEnd)
{
continue;
}
profileWriter.AddSample(cpuSample);
}
Console.WriteLine();
long outputSize = profileWriter.Write(opts.outputFileName);
Console.WriteLine("Wrote {0:N0} bytes to {1}", outputSize, opts.outputFileName);
}
}
static void Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("Use this to summarize a heap snapshot or compare multiple heap snapshots");
Console.WriteLine("from one run of a program.");
return;
}
SnapshotSummary lastAllocs = null;
string lastTracename = "";
foreach (var arg in args)
{
if (!File.Exists(arg))
{
Console.Error.WriteLine("File '{0}' does not exist.", arg);
continue;
}
using (ITraceProcessor trace = TraceProcessor.Create(arg))
{
Console.WriteLine("Summarizing '{0}'", Path.GetFileName(arg));
var allocs = GetAllocSummary(trace);
if (allocs.allocsByStackId_ == null)
{
Console.WriteLine("Ignoring trace {0}.", arg);
continue;
}
Console.WriteLine("{0,7:F2} MB from {1,9:#,#} allocations on {2,7:#,#} stacks",
allocs.totalBytes_.TotalMegabytes, allocs.allocCount_, allocs.allocsByStackId_.Count);
const int maxPrinted = 40;
Console.WriteLine("Hottest stack frames:");
// Display a summary of the first (possibly only) heap snapshot trace.
var sortedHotStackEntries = new List <KeyValuePair <string, long> >(allocs.hotStackFrames_);
sortedHotStackEntries.Sort((x, y) => y.Value.CompareTo(x.Value));
for (int i = 0; i < sortedHotStackEntries.Count && i < maxPrinted; ++i)
{
var data = sortedHotStackEntries[i];
Console.WriteLine("{0,5} allocs cross {1}", data.Value, data.Key);
}
if (lastAllocs != null)
{
Console.WriteLine("Comparing old ({0}) to new ({1}) snapshots.", Path.GetFileName(lastTracename), Path.GetFileName(arg));
if (allocs.pid_ != lastAllocs.pid_)
{
Console.WriteLine("WARNING: process IDs are different ({0} and {1}) so stack IDs may not be comparable.", lastAllocs.pid_, allocs.pid_);
}
var hotStackFramesDelta = new Dictionary <string, long>(allocs.hotStackFrames_);
// Subtract the lastAllocs stack frame counts fomr the current stack frame counts.
foreach (var entry in lastAllocs.hotStackFrames_)
{
hotStackFramesDelta.TryGetValue(entry.Key, out long count);
count -= entry.Value;
hotStackFramesDelta[entry.Key] = count;
}
Console.WriteLine("Hottest stack frame deltas:");
// Print the biggest deltas, positive then negative.
var sortedHotStackFramesDelta = new List <KeyValuePair <string, long> >(hotStackFramesDelta);
sortedHotStackFramesDelta.Sort((x, y) => y.Value.CompareTo(x.Value));
// Print the first half...
for (int i = 0; i < sortedHotStackFramesDelta.Count && i < maxPrinted / 2; ++i)
{
var data = sortedHotStackFramesDelta[i];
Console.WriteLine("{0,5} allocs cross {1}", data.Value, data.Key);
}
Console.WriteLine("...");
int start = sortedHotStackFramesDelta.Count - maxPrinted / 2;
if (start < 0)
{
start = 0;
}
for (int i = start; i < sortedHotStackFramesDelta.Count - 1; ++i)
{
var data = sortedHotStackFramesDelta[i];
Console.WriteLine("{0,5} allocs cross {1}", data.Value, data.Key);
}
ulong newOnlyStacks = 0;
ulong oldOnlyStacks = 0;
foreach (var tag in allocs.allocsByStackId_.Keys)
{
if (!lastAllocs.allocsByStackId_.ContainsKey(tag))
{
newOnlyStacks++;
}
}
foreach (var tag in lastAllocs.allocsByStackId_.Keys)
{
if (!allocs.allocsByStackId_.ContainsKey(tag))
{
oldOnlyStacks++;
}
}
Console.WriteLine(" Old snapshot had {0} unique-to-it stacks, new trace had {1} unique-to-it stacks.",
oldOnlyStacks, newOnlyStacks);
}
lastAllocs = allocs;
lastTracename = arg;
}
}
}
private static int Main(string[] cmdLineArgs)
{
ParserResult <CommandLineArguments> o = Parser.Default.ParseArguments <CommandLineArguments>(cmdLineArgs);
return(o.MapResult(
options =>
{
string sidecarJson = File.ReadAllText(options.SideCarFile);
CLogSidecar sidecar = CLogSidecar.FromJson(sidecarJson);
TextReader file = Console.In;
if (!File.Exists(options.ETLFile))
{
TraceLine(TraceType.Err, $"ETL File {options.ETLFile} doesnt exist");
return -1;
}
StreamWriter outputfile = null;
if (!String.IsNullOrEmpty(options.OutputFile))
{
outputfile = new StreamWriter(new FileStream(options.OutputFile, FileMode.Create));
}
try
{
TraceProcessorSettings traceSettings = new TraceProcessorSettings {
AllowLostEvents = true, AllowTimeInversion = true
};
using (ITraceProcessor etwfile = TraceProcessor.Create(options.ETLFile, traceSettings))
{
HashSet <Guid> ids = new HashSet <Guid>();
foreach (var m in sidecar.EventBundlesV2)
{
foreach (var prop in m.Value.ModuleProperites)
{
if (prop.Key.Equals("MANIFESTED_ETW"))
{
ids.Add(new Guid(prop.Value["ETW_Provider"]));
}
else if (prop.Key.Equals("TRACELOGGING"))
{
ids.Add(new Guid(prop.Value["ETW_Provider"]));
}
}
}
var events = etwfile.UseGenericEvents(ids.ToArray());
etwfile.Process();
foreach (var e in events.Result.Events)
{
string line = "";
try
{
Dictionary <string, IClogEventArg> fixedUpArgs = new Dictionary <string, IClogEventArg>();
string errorString = "ERROR";
if (null == e.Fields)
{
continue;
}
Dictionary <string, IClogEventArg> args = new Dictionary <string, IClogEventArg>();
foreach (var f in e.Fields)
{
args[f.Name] = new ManifestedETWEvent(f);
}
CLogDecodedTraceLine bundle = null;
int eidAsInt = -1;
foreach (var b in sidecar.EventBundlesV2)
{
Dictionary <string, string> keys;
if (!e.IsTraceLogging)
{
if (!b.Value.ModuleProperites.TryGetValue("MANIFESTED_ETW", out keys))
{
continue;
}
string eid;
if (!keys.TryGetValue("EventID", out eid))
{
continue;
}
eidAsInt = Convert.ToInt32(eid);
if (eidAsInt == e.Id)
{
bundle = b.Value;
errorString = "ERROR:" + eidAsInt;
break;
}
}
else
{
if (e.ActivityName.Equals(b.Key))
{
bundle = b.Value;
errorString = "ERROR:" + b.Key;
break;
}
}
}
if (null == bundle)
{
continue;
}
Dictionary <string, string> argMap;
if (e.IsTraceLogging)
{
argMap = new Dictionary <string, string>();
foreach (var arg in args)
{
argMap[arg.Key] = arg.Key;
}
}
else
{
argMap = sidecar.GetTracelineMetadata(bundle, "MANIFESTED_ETW");
}
var types = CLogFileProcessor.BuildTypes(sidecar.ConfigFile, null, bundle.TraceString, null, out string clean);
if (0 == types.Length)
{
errorString = bundle.TraceString;
goto toPrint;
}
int argIndex = 0;
foreach (var type in types)
{
var arg = bundle.splitArgs[argIndex];
CLogEncodingCLogTypeSearch node = sidecar.ConfigFile.FindType(arg);
switch (node.EncodingType)
{
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.Skip:
continue;
}
string lookupArgName = argMap[arg.VariableInfo.SuggestedTelemetryName];
if (!args.ContainsKey(lookupArgName))
{
Console.WriteLine($"Argmap missing {lookupArgName}");
throw new Exception("InvalidType : " + node.DefinationEncoding);
}
if (0 != node.DefinationEncoding.CompareTo(type.TypeNode.DefinationEncoding))
{
Console.WriteLine("Invalid Types in Traceline");
throw new Exception("InvalidType : " + node.DefinationEncoding);
}
fixedUpArgs[arg.VariableInfo.SuggestedTelemetryName] = args[lookupArgName];
++argIndex;
}
toPrint:
EventInformation ei = new EventInformation();
ei.Timestamp = e.Timestamp.DateTimeOffset;
ei.ProcessId = e.ProcessId.ToString("x");
ei.ThreadId = e.ThreadId.ToString("x");
DecodeAndTraceToConsole(outputfile, bundle, errorString, sidecar.ConfigFile, fixedUpArgs, ei, options.ShowTimestamps, options.ShowCPUInfo);
}
catch (Exception)
{
Console.WriteLine($"Invalid TraceLine : {line}");
}
}
}
}
catch (Exception e)
{
CLogConsoleTrace.TraceLine(TraceType.Err, "ERROR : " + e);
if (null != outputfile)
{
outputfile.WriteLine("ERROR : " + e);
}
}
finally
{
if (null != outputfile)
{
outputfile.Flush();
outputfile.Close();
}
}
return 0;
}, err =>
{
Console.WriteLine("Bad Args : " + err);
return -1;
}));
}
static void Main(string[] args)
{
string traceName = null;
string[] moduleList = null;
for (int i = 0; i < args.Length; /**/)
{
if (args[i] == "-modules")
{
++i;
if (i >= args.Length)
{
Console.Error.WriteLine("Missing module list after -modules.");
return;
}
moduleList = args[i++].Split(';');
}
else
{
if (traceName != null)
{
Console.Error.WriteLine("Unexpected argument '{0}'", args[i]);
return;
}
traceName = args[i++];
}
}
if (traceName == null)
{
Console.Error.WriteLine("usage: gWindowsETLSummary.exe trace.etl [-modules module1.dll;module2.dll");
Console.Error.WriteLine("error: too few arguments");
Console.Error.WriteLine("The (case sensitive) -modules arguments are used to get inclusive CPU sampling data.");
return;
}
if (!File.Exists(traceName))
{
// Print a more friendly error message for this case.
Console.Error.WriteLine("File '{0}' does not exist.", traceName);
return;
}
Console.WriteLine("Processing {0}...", traceName);
var settings = new TraceProcessorSettings
{
// Don't print a setup message on first run.
SuppressFirstTimeSetupMessage = true
};
try
{
using (ITraceProcessor trace = TraceProcessor.Create(traceName, settings))
ProcessTrace(trace, moduleList);
}
catch (TraceLostEventsException e)
{
// Note that wpaexporter doesn't seem to have a way to handle this,
// which is one advantage of TraceProcessing. Note that traces with
// lost events are "corrupt" in some sense so the results will be
// unpredictable.
Console.WriteLine(e.Message);
Console.WriteLine("Trying again with AllowLostEvents specified. Results may be less reliable.");
Console.WriteLine();
settings.AllowLostEvents = true;
using (ITraceProcessor trace = TraceProcessor.Create(traceName, settings))
ProcessTrace(trace, moduleList);
}
}
