public void TraceLineDiscovered(CLogDecodedTraceLine decodedTraceLine, StringBuilder results)
{
Dictionary <int, string> map = new Dictionary <int, string>();
int idx = 1;
if (skip)
{
results.Append(decodedTraceLine.match.MatchedRegEx.ToString());
return;
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Std, decodedTraceLine.match.MatchedRegEx.ToString());
int c = -1;
try
{
for (; ;)
{
foreach (var m in decodedTraceLine.configFile.AllKnownMacros())
{
map[idx] = m.MacroName;
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Std, $"{idx}. {m.MacroName}");
++idx;
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Std, $"{idx}. <skip the reset in this file and save");
string choice = Console.ReadLine();
c = Convert.ToInt32(choice);
if (c == idx)
{
skip = true;
results.Append(decodedTraceLine.match.MatchedRegEx.ToString());
return;
}
break;
}
}
catch (Exception)
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "ERROR : invalid input");
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Std, "UNIQUE ID");
string id = Console.ReadLine().Trim().ToUpper();
results.Append($"{map[c]}(");
results.Append("" + id);
results.Append($", \"{decodedTraceLine.TraceString}\"");
foreach (var arg in decodedTraceLine.splitArgs)
{
results.Append($", {arg.VariableInfo.UserSpecifiedUnModified}");
}
results.Append(");");
}
public void TraceLineDiscovered(string sourceFile, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline, StringBuilder function)
{
string priority = decodedTraceLine.GetConfigurationValue(ModuleName, "Priority");
inline.Append($"syslog({priority}, \"{decodedTraceLine.TraceString}\"");
for (int i = 0; i < decodedTraceLine.splitArgs.Length; ++i)
{
inline.Append(", " + decodedTraceLine.splitArgs[i].MacroVariableName);
}
inline.Append(");\\\n");
}
public Guid GenerateUniquenessHash(ICLogOutputModule module, CLogDecodedTraceLine traceLine, out string asString)
{
string info = traceLine.macro.MacroName + "|" + traceLine.UniqueId + "|" +
traceLine.TraceString + "|";
foreach (var arg in traceLine.splitArgs)
{
info += traceLine.configFile.FindType(arg, traceLine).EncodingType;
}
asString = info;
return(CLogFileProcessor.GenerateMD5Hash(info));
}
public CLogDecodedTraceLine DecodedTraceLine(string babbleTraceLine, out EventInformation eventInfo, out Dictionary <string, IClogEventArg> args)
{
args = SplitBabelTraceLine(babbleTraceLine);
EventInformation ei = eventInfo = new EventInformation();
if (!args.ContainsKey("name") || !args.ContainsKey("event.fields"))
{
Console.WriteLine("TraceHasNoArgs");
}
if (args.ContainsKey("timestamp"))
{
string[] bits = args["timestamp"].AsString.Split(':');
ei.Timestamp = new DateTimeOffset(Convert.ToDateTime(args["timestamp"].AsString));
}
if (args.ContainsKey("stream.packet.context"))
{
string packetContext = args["stream.packet.context"].AsString;
string packetFields = packetContext.Substring(1, packetContext.Length - 2).Trim();
var cpuArgs = SplitBabelTraceLine(packetFields);
ei.CPUId = cpuArgs["cpu_id"].AsString;
}
if (args.ContainsKey("stream.event.context"))
{
string packetContext = args["stream.event.context"].AsString;
string packetFields = packetContext.Substring(1, packetContext.Length - 2).Trim();
var cpuArgs = SplitBabelTraceLine(packetFields);
ei.ThreadId = Convert.ToInt64(cpuArgs["vtid"].AsString).ToString("x");
ei.ProcessId = Convert.ToInt64(cpuArgs["vpid"].AsString).ToString("x");
}
string name = args["name"].AsString.Split(':')[1];
CLogDecodedTraceLine bundle = _sidecar.FindBundle(name);
string fields = args["event.fields"].AsString.Substring(1, args["event.fields"].AsString.Length - 2).Trim();
if (0 == fields.Length)
{
args = new Dictionary <string, IClogEventArg>();
}
else
{
args = SplitBabelTraceLine(fields);
}
return(bundle);
}
public Guid GenerateUniquenessHash(ICLogOutputModule module, CLogDecodedTraceLine decodedTraceLine, out string asString)
{
string info = decodedTraceLine.macro.MacroName + "|" + decodedTraceLine.UniqueId + "|" +
decodedTraceLine.TraceString + "|";
foreach (var arg in decodedTraceLine.splitArgs)
{
if (arg.TypeNode.EncodingType == CLogEncodingType.UserEncodingString || arg.TypeNode.EncodingType == CLogEncodingType.UniqueAndDurableIdentifier)
{
continue;
}
info += arg.TypeNode.EncodingType;
}
asString = info;
return(CLogFileProcessor.GenerateMD5Hash(info));
}
public bool IsUnique(ICLogOutputModule module, CLogDecodedTraceLine traceLine, out CLogTraceLineInformation existingTraceInformation)
{
existingTraceInformation = TraceInformation
.Where(x => x.TraceID.Equals(traceLine.UniqueId)).FirstOrDefault();
if (null == existingTraceInformation)
{
return(true);
}
string asString;
Guid hash = GenerateUniquenessHash(module, traceLine, out asString);
if (hash != existingTraceInformation.UniquenessHash)
{
return(false);
}
return(true);
}
public void Insert(ICLogOutputModule module, CLogDecodedTraceLine traceLine)
{
string asString;
Guid hash = GenerateUniquenessHash(module, traceLine, out asString);
CLogTraceLineInformation info = TraceInformation
.Where(x => x.TraceID.Equals(traceLine.UniqueId)).FirstOrDefault();
if (null == info)
{
info = new CLogTraceLineInformation();
info.Unsaved = true;
info.PreviousFileMatch = traceLine;
info.TraceID = traceLine.UniqueId;
info.UniquenessHash = hash;
TraceInformation.Add(info);
}
if (info.UniquenessHash != hash)
{
throw new CLogEnterReadOnlyModeException("DuplicateID", CLogHandledException.ExceptionType.DuplicateId, traceLine.match);
}
}
public void TraceLineDiscovered(string sourceFile, CLogOutputInfo outputInfo, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline, StringBuilder function)
{
string priority = decodedTraceLine.GetConfigurationValue(ModuleName, "Priority");
inline.Append($"syslog({priority}, \"{decodedTraceLine.TraceString}\"");
foreach (var a in decodedTraceLine.splitArgs)
{
CLogFileProcessor.CLogVariableBundle arg = a;
if (!arg.TypeNode.IsEncodableArg)
{
continue;
}
CLogEncodingCLogTypeSearch node = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
switch (node.EncodingType)
{
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.Skip:
continue;
}
inline.Append(", " + arg.MacroVariableName);
}
inline.Append(");\\\n");
}
public void TraceLineDiscovered(CLogDecodedTraceLine decodedTraceLine, CLogOutputInfo outputInfo, StringBuilder results)
{
Dictionary <int, string> map = new Dictionary <int, string>();
int idx = 1;
if (skip)
{
results.Append(decodedTraceLine.match.MatchedRegExX.ToString());
return;
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Std, decodedTraceLine.match.MatchedRegExX.ToString());
int c = -1;
try
{
for (; ;)
{
foreach (var m in decodedTraceLine.configFile.AllKnownMacros())
{
map[idx] = m.MacroName;
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Std, $"{idx}. {m.MacroName}");
++idx;
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Std, $"{idx}. <skip the rest in this file and save>");
string choice = null;
while (String.IsNullOrEmpty(choice))
{
try
{
choice = Console.ReadLine();
c = Convert.ToInt32(choice);
}
catch (Exception)
{
Console.WriteLine("try again please");
}
}
if (c == idx)
{
skip = true;
results.Append(decodedTraceLine.match.MatchedRegExX.ToString());
return;
}
break;
}
}
catch (Exception)
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "ERROR : invalid input");
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Std, "UNIQUE ID");
string id = Console.ReadLine().Trim().ToUpper();
while (takenIds.Contains(id))
{
Console.WriteLine("ID is taken please use a unique ID");
id = Console.ReadLine().Trim().ToUpper();
}
takenIds.Add(id);
results.Append($"{map[c]}(");
results.Append("" + id);
results.Append($", \"{decodedTraceLine.TraceString}\"");
for (int i = 2; i < decodedTraceLine.splitArgs.Length; ++i)
{
var arg = decodedTraceLine.splitArgs[i];
results.Append($", {arg.VariableInfo.UserSuppliedTrimmed}");
}
results.Append(");");
}
public void TraceLineDiscovered(string sourceFile, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline, StringBuilder function)
{
//
// Generate a function name that is unique; this is where you'll attach a DTrace probe.
//
// ScopePrefix is passed in during compliation, it is a unique name that indicates the library
//
string uid = "DTRACE_" + decodedTraceLine.configFile.ScopePrefix + "_" + Path.GetFileName(sourceFile).Replace(".", "_") + "_" + decodedTraceLine.UniqueId;
uid = uid.Replace("{", "");
uid = uid.Replace("}", "");
uid = uid.Replace("-", "");
string argsString = string.Empty;
string macroString = string.Empty;
foreach (var arg in decodedTraceLine.splitArgs)
{
CLogEncodingCLogTypeSearch v = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
if (!v.Synthesized)
{
string seperatorA = "";
string seperatorB = "";
if (string.IsNullOrEmpty(argsString))
{
seperatorA = ",";
seperatorB = "";
}
else
{
seperatorA = "";
seperatorB = ",";
}
// If the encided type is 'binary' (length and payload) - for DTrace we emit the payload
// length with the variable name <suggestedName>_len
if (CLogEncodingType.ByteArray == v.EncodingType)
{
argsString += $"{seperatorB} unsigned int {arg.MacroVariableName}_len{seperatorA}";
macroString += $"{seperatorB} {arg.MacroVariableName}_len{seperatorA}";
}
argsString += $"{seperatorB} {v.CType} {arg.MacroVariableName}";
macroString += $"{seperatorB} {arg.MacroVariableName}";
}
}
//
// Emit into the CLOG macro (this is the actual code that goes into the product)
//
macroPrefix.AppendLine("void " + uid + "(" + argsString + ");\r\n");
//
// Emit our foward delcaration and implementation into the .c file that CLOG generates
//
if (!alreadyEmitted.Contains(uid))
{
inline.AppendLine($"{uid}({macroString});\\");
function.AppendLine($"void {uid}({argsString})" + "{}\r\n\r\n");
alreadyEmitted.Add(uid);
}
}
private string MapCLOGStringToManifestString(CLogDecodedTraceLine decodedTraceLine)
{
return(decodedTraceLine.CleanedString);
}
public void TraceLineDiscovered(string sourceFile, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline, StringBuilder function)
{
if (!emittedHeader)
{
function.AppendLine($"// SYSTEMTAP {DateTime.Now}------");
function.AppendLine("#include <sys/sdt.h>");
emittedHeader = true;
}
//
// Generate a function name that is unique; this is where you'll attach a DTrace probe.
//
// ScopePrefix is passed in during compliation, it is a unique name that indicates the library
//
string uid = "PROBE_DTRACE_" + decodedTraceLine.configFile.ScopePrefix + "_" + Path.GetFileName(sourceFile).Replace(".", "_");
uid = uid.Replace("{", "");
uid = uid.Replace("}", "");
uid = uid.Replace("-", "");
//
// Only emit the function once; we may be called multiple times should someone emit an event multiple times in the same file
// (usually error paths)
//
if (alreadyEmitted.Contains(uid))
{
return;
}
alreadyEmitted.Add(uid);
string argsString = string.Empty;
string macroString = string.Empty;
foreach (var arg in decodedTraceLine.splitArgs)
{
CLogEncodingCLogTypeSearch v = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
if (!v.Synthesized)
{
string seperatorA = "";
string seperatorB = "";
if (string.IsNullOrEmpty(argsString))
{
seperatorA = ",";
seperatorB = "";
}
else
{
seperatorA = "";
seperatorB = ",";
}
// If the encided type is 'binary' (length and payload) - for DTrace we emit the payload
// length with the variable name <suggestedName>_len
if (CLogEncodingType.ByteArray == v.EncodingType)
{
argsString += $"{seperatorB} unsigned int {arg.MacroVariableName}_len{seperatorA}";
macroString += $"{seperatorB} {arg.MacroVariableName}_len{seperatorA}";
}
argsString += $"{seperatorB} {v.CType} {arg.MacroVariableName}";
macroString += $"{seperatorB} {arg.MacroVariableName}";
}
}
//
// Emit a forward declare of our function into the header file
//
inline.AppendLine($"{uid}({macroString});\\");
//
// Emit into the CLOG macro (this is the actual code that goes into the product)
//
macroPrefix.AppendLine("void " + uid + "(" + argsString + ");\r\n");
//
// Emit our implementation into the .c file that CLOG generates
//
function.AppendLine($"void {uid}({argsString})" + "{");
if (0 == decodedTraceLine.splitArgs.Length)
{
function.AppendLine($"DTRACE_PROBE({decodedTraceLine.configFile.ScopePrefix}, {decodedTraceLine.UniqueId});");
}
else
{
function.Append($"DTRACE_PROBE{decodedTraceLine.splitArgs.Length}({decodedTraceLine.configFile.ScopePrefix}, {decodedTraceLine.UniqueId}");
foreach (var arg in decodedTraceLine.splitArgs)
{
function.Append($", {arg.MacroVariableName}");
}
function.AppendLine(");");
}
function.AppendLine("}\r\n\r\n");
}
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;
}));
}
private static int Main(string[] args)
{
ParserResult <CommandLineArguments> o = Parser.Default.ParseArguments <CommandLineArguments>(args);
return(o.MapResult(
options =>
{
string sidecarJson = File.ReadAllText(options.SideCarFile);
CLogSidecar textManifest = CLogSidecar.FromJson(sidecarJson);
TextReader file = Console.In;
if (!string.IsNullOrEmpty(options.BabelTrace))
{
file = new StreamReader(options.BabelTrace);
}
string line;
LTTNGEventDecoder lttngDecoder = new LTTNGEventDecoder(textManifest);
int lines = 0;
StreamWriter outputfile = null;
if (!String.IsNullOrEmpty(options.OutputFile))
{
outputfile = new StreamWriter(new FileStream(options.OutputFile, FileMode.Create));
}
DateTimeOffset startTime = DateTimeOffset.Now;
try
{
while (!string.IsNullOrEmpty(line = file.ReadLine()))
{
++lines;
if (0 == lines % 10000)
{
Console.WriteLine($"Line : {lines}");
}
Dictionary <string, IClogEventArg> valueBag;
EventInformation ei;
CLogDecodedTraceLine bundle = lttngDecoder.DecodedTraceLine(line, out ei, out valueBag);
DecodeAndTraceToConsole(outputfile, bundle, line, textManifest.ConfigFile, valueBag, ei, options.ShowTimestamps, options.ShowCPUInfo);
}
}
catch (Exception e)
{
CLogConsoleTrace.TraceLine(TraceType.Err, "ERROR : " + e);
if (null != outputfile)
{
outputfile.WriteLine("ERROR : " + e);
}
}
finally
{
if (null != outputfile)
{
outputfile.Flush();
outputfile.Close();
}
}
Console.WriteLine($"Decoded {lines} in {DateTimeOffset.Now - startTime}");
return 0;
}, err =>
{
Console.WriteLine("Bad Args : " + err);
return -1;
}));
}
public void TraceLineDiscovered(string sourceFile, CLogOutputInfo outputInfo, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline, StringBuilder function)
{
CLogFileProcessor.DecomposedString clean;
CLogFileProcessor.CLogTypeContainer[] types = CLogFileProcessor.BuildTypes(decodedTraceLine.configFile, null, decodedTraceLine.TraceString, null, out clean);
CLogExportModuleDefination moduleSettings = decodedTraceLine.GetMacroConfigurationProfile().FindExportModule(ModuleName);
string printmacro;
if (!moduleSettings.CustomSettings.TryGetValue("PrintMacro", out printmacro))
{
printmacro = "printf";
}
if (!emittedHeader)
{
string printHeader;
if (!moduleSettings.CustomSettings.TryGetValue("PrintHeader", out printHeader))
{
printHeader = "stdio.h";
}
emittedHeader = true;
}
//
// Only emit the function once; we may be called multiple times should someone emit an event multiple times in the same file
// (usually error paths)
//
string argsString = string.Empty;
string macroString = string.Empty;
foreach (var arg in decodedTraceLine.splitArgs)
{
if (!arg.TypeNode.Synthesized &&
arg.TypeNode.EncodingType != CLogEncodingType.UniqueAndDurableIdentifier &&
arg.TypeNode.EncodingType != CLogEncodingType.UserEncodingString)
{
string seperatorA = "";
string seperatorB = "";
if (string.IsNullOrEmpty(argsString))
{
seperatorA = ",";
seperatorB = "";
}
else
{
seperatorA = "";
seperatorB = ",";
}
// If the encided type is 'binary' (length and payload) - for DTrace we emit the payload
// length with the variable name <suggestedName>_len
if (CLogEncodingType.ByteArray == arg.TypeNode.EncodingType)
{
argsString += $"{seperatorB} unsigned int {arg.VariableInfo.SuggestedTelemetryName}_len{seperatorA}";
macroString += $"{seperatorB} {arg.MacroVariableName}_len{seperatorA}";
}
argsString += $"{seperatorB} {arg.TypeNode.CType} {arg.MacroVariableName}";
macroString += $"{seperatorB} {arg.MacroVariableName}";
}
}
string printf = "";
foreach (var t in types)
{
printf += t.LeadingString;
switch (t.TypeNode.EncodingType)
{
case CLogEncodingType.Int32:
printf += "%d";
break;
case CLogEncodingType.UInt32:
printf += "%u";
break;
case CLogEncodingType.Int64:
printf += "%lld";
break;
case CLogEncodingType.UInt64:
printf += "%llu";
break;
case CLogEncodingType.ANSI_String:
printf += "%s";
break;
case CLogEncodingType.UNICODE_String:
printf += "%S";
break;
case CLogEncodingType.Pointer:
printf += "0x%llx";
break;
case CLogEncodingType.GUID:
printf += "%p";
break;
case CLogEncodingType.Int16:
printf += "%d";
break;
case CLogEncodingType.UInt16:
printf += "%d";
break;
case CLogEncodingType.Int8:
printf += "%d";
break;
case CLogEncodingType.UInt8:
printf += "%d";
break;
case CLogEncodingType.ByteArray:
printf += "[Not_Supported]";
break;
}
}
//
// Print the remainder of user text (the tail end); if there are no types at all then 'TraceString' is just a constant string
//
if (types.Length >= 1)
{
string tail = decodedTraceLine.TraceString.Substring(types[types.Length - 1].ArgStartingIndex + types[types.Length - 1].ArgLength);
printf += tail;
}
else
{
printf += decodedTraceLine.TraceString;
}
printf += "\\n";
inline.Append($" {printmacro}(\"{printf}\"");
foreach (var arg in decodedTraceLine.splitArgs)
{
if (arg.TypeNode.Synthesized || arg.TypeNode.EncodingType == CLogEncodingType.UniqueAndDurableIdentifier || arg.TypeNode.EncodingType == CLogEncodingType.UserEncodingString)
{
continue;
}
string cast = "";
switch (arg.TypeNode.EncodingType)
{
case CLogEncodingType.Int32:
//cast = "(int)";
break;
case CLogEncodingType.UInt32:
//cast = "(unsigned int)";
break;
case CLogEncodingType.Int64:
//cast = "(__int64)";
break;
case CLogEncodingType.UInt64:
//cast = "(unsigned __int64)";
break;
case CLogEncodingType.ANSI_String:
break;
case CLogEncodingType.UNICODE_String:
break;
case CLogEncodingType.Pointer:
cast = "(unsigned long long int)";
break;
case CLogEncodingType.GUID:
cast = "(void*)";
break;
case CLogEncodingType.Int16:
//cast = "(__int16)";
break;
case CLogEncodingType.UInt16:
//cast = "(unsigned __int16)";
break;
case CLogEncodingType.Int8:
//cast = "(int)";
break;
case CLogEncodingType.UInt8:
//cast = "(int)";
break;
case CLogEncodingType.ByteArray:
//cast = "(void*)";
continue;
}
inline.Append($", {cast}(" + arg.MacroVariableName + ")");
}
inline.Append(");");
}
public void TraceLineDiscovered(string sourceFile, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline, StringBuilder function)
{
int hashUInt;
string hash;
decodedTraceLine.macro.DecodeUniqueId(decodedTraceLine.match, decodedTraceLine.UniqueId, out hash, out hashUInt);
int usedArguments = 0;
foreach (var a in decodedTraceLine.splitArgs)
{
CLogFileProcessor.CLogVariableBundle arg = a;
CLogEncodingCLogTypeSearch node = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
switch (node.EncodingType)
{
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.ByteArray:
usedArguments += 2;
break;
default:
++usedArguments;
break;
}
}
if (usedArguments >= 11)
{
throw new ReadOnlyException($"Too Many arguments in {hash}, LTTNG accepts a max of 10");
}
lttngFile.AppendLine("");
lttngFile.AppendLine("");
lttngFile.AppendLine("");
lttngFile.AppendLine("/*----------------------------------------------------------");
lttngFile.AppendLine($"// Decoder Ring for {decodedTraceLine.UniqueId}");
lttngFile.AppendLine($"// {decodedTraceLine.TraceString}");
lttngFile.AppendLine($"// {decodedTraceLine.match.MatchedRegEx}");
foreach (var arg in decodedTraceLine.splitArgs)
{
lttngFile.AppendLine($"// {arg.MacroVariableName} = {arg.VariableInfo.SuggestedTelemetryName} = {arg.VariableInfo.UserSuppliedTrimmed}");
}
lttngFile.AppendLine("----------------------------------------------------------*/");
lttngFile.AppendLine($"TRACEPOINT_EVENT({_lttngProviderName}, {hash},");
int argNum = 0;
lttngFile.AppendLine(" TP_ARGS(");
foreach (var a in decodedTraceLine.splitArgs)
{
CLogFileProcessor.CLogVariableBundle arg = a;
CLogEncodingCLogTypeSearch node = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
switch (node.EncodingType)
{
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.Skip:
continue;
case CLogEncodingType.UNICODE_String:
continue;
}
if (0 != argNum)
{
if (CLogEncodingType.ByteArray == node.EncodingType)
{
lttngFile.Append(",");
lttngFile.AppendLine("");
lttngFile.Append($" unsigned int, {arg.VariableInfo.SuggestedTelemetryName}_len");
}
lttngFile.Append(",");
lttngFile.AppendLine("");
lttngFile.Append($" {ConvertToClogType(node)}, {arg.VariableInfo.SuggestedTelemetryName}");
}
else
{
if (CLogEncodingType.ByteArray == node.EncodingType)
{
lttngFile.Append($" unsigned int, {arg.VariableInfo.SuggestedTelemetryName}_len");
lttngFile.Append(",");
lttngFile.AppendLine("");
}
lttngFile.Append($" {ConvertToClogType(node)}, {arg.VariableInfo.SuggestedTelemetryName}");
}
++argNum;
}
lttngFile.Append("), ");
lttngFile.AppendLine("");
lttngFile.AppendLine(" TP_FIELDS(");
foreach (var a in decodedTraceLine.splitArgs)
{
CLogFileProcessor.CLogVariableBundle arg = a;
CLogEncodingCLogTypeSearch node = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
switch (node.EncodingType)
{
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.Skip:
continue;
case CLogEncodingType.UNICODE_String:
continue;
case CLogEncodingType.ByteArray:
lttngFile.AppendLine(
$" ctf_integer(unsigned int, {arg.VariableInfo.SuggestedTelemetryName}_len, {arg.VariableInfo.SuggestedTelemetryName}_len)");
lttngFile.AppendLine(
$" ctf_sequence(char, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName}, unsigned int, {arg.VariableInfo.SuggestedTelemetryName}_len)");
break;
case CLogEncodingType.Int8:
lttngFile.AppendLine(
$" ctf_integer(char, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
case CLogEncodingType.UInt8:
lttngFile.AppendLine(
$" ctf_integer(unsigned char, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
case CLogEncodingType.Int16:
lttngFile.AppendLine(
$" ctf_integer(short, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
case CLogEncodingType.UInt16:
lttngFile.AppendLine(
$" ctf_integer(unsigned short, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
case CLogEncodingType.Int32:
lttngFile.AppendLine(
$" ctf_integer(int, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
case CLogEncodingType.UInt32:
lttngFile.AppendLine(
$" ctf_integer(unsigned int, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
case CLogEncodingType.Int64:
lttngFile.AppendLine(
$" ctf_integer(int64_t, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
case CLogEncodingType.UInt64:
lttngFile.AppendLine(
$" ctf_integer(uint64_t, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
case CLogEncodingType.Pointer:
lttngFile.AppendLine(
$" ctf_integer_hex(uint64_t, {arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
case CLogEncodingType.ANSI_String:
lttngFile.AppendLine(
$" ctf_string({arg.VariableInfo.SuggestedTelemetryName}, {arg.VariableInfo.SuggestedTelemetryName})");
break;
default:
throw new CLogEnterReadOnlyModeException("LTTNG:UnknownType:" + node.EncodingType, CLogHandledException.ExceptionType.EncoderIncompatibleWithType, decodedTraceLine.match);
}
++argNum;
}
lttngFile.AppendLine(" )"); //TRACEPONT_ARGS
lttngFile.AppendLine(")"); //TRACEPOINT_EVENT
string traceLine = $"tracepoint({_lttngProviderName}, {hash} ";
foreach (var a in decodedTraceLine.splitArgs)
{
CLogFileProcessor.CLogVariableBundle arg = a;
CLogEncodingCLogTypeSearch node = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
if (string.IsNullOrEmpty(node.CType))
{
throw new ReadOnlyException($"Missing CType Field : {node.DefinationEncoding}");
}
switch (node.EncodingType)
{
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.Skip:
continue;
case CLogEncodingType.UNICODE_String:
continue;
}
if (node.EncodingType == CLogEncodingType.ByteArray)
{
traceLine += $", {arg.MacroVariableName}_len";
}
traceLine += $", {arg.MacroVariableName}";
}
traceLine += ");\\";
inline.AppendLine(traceLine);
}
public void TraceLineDiscovered(string sourceFile, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline,
StringBuilder function)
{
int hashUInt;
string hash;
CLogExportModuleDefination moduleSettings = decodedTraceLine.GetMacroConfigurationProfile().FindExportModule(ModuleName);
decodedTraceLine.macro.DecodeUniqueId(decodedTraceLine.match, decodedTraceLine.UniqueId, out hash, out hashUInt);
if (knownHashes.Contains(hash))
{
return;
}
knownHashes.Add(hash);
inline.AppendLine(
$"__annotation(L\"Debug\", L\"CLOG\", L\"{hash}\"); \\"); //, msg, id, \"{sourceFile}\");");
string traceloggingLine = "TraceLoggingWrite(clog_hTrace, \"" + decodedTraceLine.UniqueId +
"\"";
foreach (var a in decodedTraceLine.splitArgs)
{
CLogFileProcessor.CLogVariableBundle arg = a;
CLogEncodingCLogTypeSearch node = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
switch (node.EncodingType)
{
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.Skip:
continue;
}
//
// Documentation for each of the TraceLogging macros
// https://docs.microsoft.com/en-gb/windows/win32/tracelogging/tracelogging-wrapper-macros
//
switch (node.EncodingType)
{
case CLogEncodingType.Int8:
traceloggingLine += ",\\\n TraceLoggingInt8" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.UInt8:
traceloggingLine += ",\\\n TraceLoggingUInt8" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.Int16:
traceloggingLine += ",\\\n TraceLoggingInt16" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.UInt16:
traceloggingLine += ",\\\n TraceLoggingUInt16" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.Int32:
traceloggingLine += ",\\\n TraceLoggingInt32" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.UInt32:
traceloggingLine += ",\\\n TraceLoggingUInt32" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.Int64:
traceloggingLine += ",\\\n TraceLoggingInt64" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.UInt64:
traceloggingLine += ",\\\n TraceLoggingUInt64" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.Pointer:
traceloggingLine += ",\\\n TraceLoggingPointer" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.ByteArray:
traceloggingLine += ",\\\n TraceLoggingUInt8Array" + $"({arg.MacroVariableName}, {arg.MacroVariableName}_len, \"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.ANSI_String:
traceloggingLine += ",\\\n TraceLoggingString" + $"((const char *)({arg.MacroVariableName}),\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
case CLogEncodingType.UNICODE_String:
traceloggingLine += ",\\\n TraceLoggingWideString" + $"({arg.MacroVariableName},\"{arg.VariableInfo.SuggestedTelemetryName}\")";
break;
}
}
// Emit keywords (if supplied by the user)
if (moduleSettings.CustomSettings.ContainsKey("Keyword"))
{
traceloggingLine += ",\\\n TraceLoggingKeyword" + $"({moduleSettings.CustomSettings["Keyword"]})";
}
if (moduleSettings.CustomSettings.ContainsKey("Level"))
{
traceloggingLine += ",\\\n TraceLoggingLevel" + $"({moduleSettings.CustomSettings["Level"]})";
}
traceloggingLine += "); \\";
inline.AppendLine(traceloggingLine);
}
public void TraceLineDiscovered(string sourceFile, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline, StringBuilder function)
{
string hash = decodedTraceLine.UniqueId;
CLogExportModuleDefination moduleSettings = decodedTraceLine.GetMacroConfigurationProfile().FindExportModule(_ModuleName);
if (!_inited)
{
if (!moduleSettings.CustomSettings.ContainsKey("ETWManifestFile"))
{
throw new CLogEnterReadOnlyModeException("ETWManifestFileNotSpecified", CLogHandledException.ExceptionType.MustSpecifiyETWManifest, decodedTraceLine.match);
}
xmlFileName = moduleSettings.CustomSettings["ETWManifestFile"];
xmlFileName = Path.Combine(Path.GetDirectoryName(decodedTraceLine.macro.ConfigFileWithMacroDefination), xmlFileName);
Init();
}
if (!moduleSettings.CustomSettings.ContainsKey("ETW_Provider"))
{
Console.WriteLine($"The 'CustomSettings' dictionary for macro {decodedTraceLine.macro.MacroName} does not contain a GUID for the EtwProvider");
Console.WriteLine(" Please add an entry and rerun");
Console.WriteLine("");
Console.WriteLine($"Configuration File : {decodedTraceLine.configFile.FilePath}");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("");
throw new CLogEnterReadOnlyModeException("ETW_Provider:NotSpecified", CLogHandledException.ExceptionType.MustSpecifyETWProvider, decodedTraceLine.match);
}
Guid providerId = new Guid(moduleSettings.CustomSettings["ETW_Provider"]);
ManifestInformation manifest = FindProviderCache(providerId);
string eventNamePrefix;
if (!moduleSettings.CustomSettings.TryGetValue("EventNamePrefix", out eventNamePrefix))
{
eventNamePrefix = string.Empty;
}
if (null == manifest)
{
Console.WriteLine($"Unable to locate ETW provider {providerId} in CLOG macro {decodedTraceLine.macro.MacroName}");
Console.WriteLine(" CLOG will not create this provider within the manifest; it will only add to an existing provider");
Console.WriteLine(" please consult the MSDN documentation for an ETW manifest for instructions");
Console.WriteLine("");
Console.WriteLine($"Macro: {providerId} is defined in {decodedTraceLine.configFile.FilePath}");
Console.WriteLine($"ETW Manifest : is set as {xmlFileName}");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("");
throw new CLogEnterReadOnlyModeException("ManifestedETWProviderNotFoundInManifest", CLogHandledException.ExceptionType.ManifestedETWProviderNotFound, decodedTraceLine.match);
}
//
// Only allow a hash one time for now....
//
if (manifest.knownHashes.Contains(hash))
{
return;
}
manifest.knownHashes.Add(hash);
//
// See if our event already exists - if it does we do not want to add it a second time
//
List <XmlElement> toRemove = new List <XmlElement>();
XmlElement newEvent = null;
foreach (var p in manifest.events.ChildNodes)
{
if (!(p is XmlElement))
{
continue;
}
XmlElement pe = (XmlElement)p;
if (pe.Name == "event")
{
if (!pe.HasAttribute("symbol"))
{
continue;
}
string symbol = pe.GetAttribute("symbol");
if (0 == symbol.CompareTo(eventNamePrefix + hash))
{
toRemove.Add(pe);
newEvent = pe;
break;
}
}
}
//
// Add the event if it doesnt already exist
//
if (null == newEvent)
{
newEvent = doc.CreateElement("event", manifest.events.NamespaceURI);
manifest.events.AppendChild(newEvent);
_dirty = true;
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $"Adding event {eventNamePrefix + hash} to ETW manifest {xmlFileName}");
}
int hashUInt;
string eventAsString;
decodedTraceLine.macro.DecodeUniqueId(decodedTraceLine.match, hash, out eventAsString, out hashUInt);
uint eventId;
if (!newEvent.HasAttribute("value"))
{
eventId = FindUnusedEventId(providerId, decodedTraceLine.match);
SetAttribute(newEvent, "value", eventId.ToString());
}
else
{
eventId = Convert.ToUInt32(newEvent.GetAttribute("value"));
}
//
// Store the eventID for future decode as well as every configuration setting attached to this module
//
decodedTraceLine.AddConfigFileProperty(ModuleName, "EventID", eventId.ToString());
foreach (var setting in moduleSettings.CustomSettings)
{
decodedTraceLine.AddConfigFileProperty(ModuleName, setting.Key, setting.Value);
}
SetAttribute(newEvent, "symbol", eventNamePrefix + hash);
string oldTemplate = null;
if (newEvent.HasAttribute("template"))
{
oldTemplate = newEvent.GetAttribute("template");
}
string templateId = DiscoverOrCreateTemplate(decodedTraceLine, sidecar, providerId, oldTemplate, eventId);
SetAttribute(newEvent, "template", templateId);
if (moduleSettings.CustomSettings.ContainsKey("Level"))
{
SetAttribute(newEvent, "level", moduleSettings.CustomSettings["Level"]);
}
else
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Wrn, $"Manifested ETW Level not specified; if you desire a Level, add 'Level' to CustomSettings in {decodedTraceLine.configFile.FilePath}");
}
if (moduleSettings.CustomSettings.ContainsKey("Keywords"))
{
SetAttribute(newEvent, "keywords", moduleSettings.CustomSettings["Keywords"]);
}
else
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Wrn, $"Manifested ETW Keywords not specified; if you desire a Keyword, add 'Keywords' to CustomSettings in {decodedTraceLine.configFile.FilePath}");
}
//
// Construct the function signature
//
string traceLine = $"EventWrite{eventNamePrefix + hash}(";
bool haveMultipleArgs = false;
foreach (var a in decodedTraceLine.splitArgs)
{
CLogFileProcessor.CLogVariableBundle arg = a;
CLogEncodingCLogTypeSearch node = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
switch (node.EncodingType)
{
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.Skip:
continue;
}
if (haveMultipleArgs)
{
traceLine += ", ";
}
haveMultipleArgs = true;
switch (node.EncodingType)
{
case CLogEncodingType.ByteArray:
traceLine += $"{arg.MacroVariableName}_len, {arg.MacroVariableName}";
continue;
default:
traceLine += $"{arg.MacroVariableName}";
break;
}
}
traceLine += "); \\";
inline.AppendLine(traceLine);
Save(decodedTraceLine.match);
}
private string DiscoverOrCreateTemplate(CLogDecodedTraceLine traceLine, CLogSidecar sidecar, Guid providerId, string existingTemplateName, uint eventId)
{
string hash = "";
//
// Construct a list of the desired types - we'll use this to see if we can find a preexisting suitable template
//
List <TemplateNode> listofArgsAsSpecifiedBySourceFile = ConstructTemplateArgs(traceLine);
string templateId = existingTemplateName;
if (string.IsNullOrEmpty(existingTemplateName))
{
templateId = "template_" + hash;
foreach (TemplateNode arg in listofArgsAsSpecifiedBySourceFile)
{
templateId += arg.Hash;
}
}
//
// See if the template already exists; for example from a different file
//
ManifestInformation manifest = FindProviderCache(providerId);
XmlElement template = null;
foreach (var p in manifest.templates.ChildNodes)
{
if (!(p is XmlElement))
{
continue;
}
XmlElement pe = (XmlElement)p;
if (pe.Name == "template")
{
if (!pe.HasAttribute("tid"))
{
continue;
}
string tid = pe.GetAttribute("tid");
if (0 == tid.CompareTo(templateId))
{
template = pe;
break;
}
}
}
//
// If we dont have an existing template, add one
//
if (null == template)
{
template = doc.CreateElement("template", manifest.events.NamespaceURI);
foreach (var arg in listofArgsAsSpecifiedBySourceFile)
{
var dataNode = doc.CreateElement("data", manifest.events.NamespaceURI);
dataNode.SetAttribute("name", arg.Name);
if (!string.IsNullOrEmpty(arg.LengthOfSelf))
{
dataNode.SetAttribute("length", arg.LengthOfSelf);
}
dataNode.SetAttribute("inType", arg.Type);
template.AppendChild(dataNode);
}
// Only apply a template ID if it's not empty - otherwise choose the default
if (!templateId.Equals("templateId_"))
{
template.SetAttribute("tid", templateId);
}
manifest.templates.AppendChild(template);
}
//
//
int argIdx = 0;
Dictionary <string, string> argLookup = sidecar.GetTracelineMetadata(traceLine, ModuleName);
if (null == argLookup)
{
argLookup = new Dictionary <string, string>();
}
foreach (var a in template.ChildNodes)
{
if (!(a is XmlElement))
{
continue;
}
XmlElement pe = (XmlElement)a;
if (pe.Name != "data")
{
continue;
}
string inType = pe.GetAttribute("inType");
string name = pe.GetAttribute("name");
if (listofArgsAsSpecifiedBySourceFile.Count <= argIdx)
{
if (traceLine.configFile.DeveloperMode)
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Template Argument Type Mismatch - overwriting due to developer mode");
_dirty = true;
return(DiscoverOrCreateTemplate(traceLine, sidecar, providerId, null, eventId));
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Template Argument Type Mismatch - manifested ETW template and CLOG string differ");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event ID : {eventId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event Provider : {providerId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event UID : {traceLine.UniqueId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, "Recommended Course of action:");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 1. (best) from within the manifest, delete the template ({templateId}) from your event ({eventId})");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 2. cleanup your template to be in this format");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 3. set the environment variable CLOG_DEVELOPMENT_MODE=1 ($env:CLOG_DEVELOPMENT_MODE=1)");
throw new CLogEnterReadOnlyModeException("ETWManifestTypeMismatch", CLogHandledException.ExceptionType.ETWTypeMismatch, traceLine.match);
}
TemplateNode templateReference = listofArgsAsSpecifiedBySourceFile[argIdx];
argLookup[templateReference.ArgBundle.MacroVariableName] = name;
if (templateReference.Type != inType)
{
if (traceLine.configFile.DeveloperMode)
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Template Argument Type Mismatch - overwriting due to developer mode");
_dirty = true;
return(DiscoverOrCreateTemplate(traceLine, sidecar, providerId, null, eventId));
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Template Argument Type Mismatch: ");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event ID : {eventId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event Provider : {providerId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event UID : {traceLine.UniqueId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Mismatch Arg Name : {name}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" CLOG specified Type : {templateReference.Type}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" ETW Manifest Type : {inType}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Source Line:");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, CLogConsoleTrace.GetFileLine(traceLine.match));
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, traceLine.match.MatchedRegEx.ToString());
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, "Recommended Course of action:");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 1. (best) from within the manifest, delete the template ({templateId}) from your event ({eventId})");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 2. cleanup your template to be in this format");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 3. set the environment variable CLOG_DEVELOPMENT_MODE=1 ($env:CLOG_DEVELOPMENT_MODE=1)");
foreach (var t in listofArgsAsSpecifiedBySourceFile)
{
if (string.IsNullOrEmpty(t.LengthOfSelf))
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" name={t.Name} inType={t.Type}");
}
else
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" name={t.Name} inType={t.Type} length={t.LengthOfSelf}");
}
}
throw new CLogEnterReadOnlyModeException("ETWManifestTypeMismatch", CLogHandledException.ExceptionType.ETWTypeMismatch, traceLine.match);
}
++argIdx;
}
//
// Store our metadata into the side car
//
sidecar.SetTracelineMetadata(traceLine, ModuleName, argLookup);
return(templateId);
}
private List <TemplateNode> ConstructTemplateArgs(CLogDecodedTraceLine traceLine)
{
List <TemplateNode> listOfTemplateArgs = new List <TemplateNode>();
foreach (var a2 in traceLine.splitArgs)
{
CLogFileProcessor.CLogVariableBundle arg = a2;
CLogEncodingCLogTypeSearch node = traceLine.configFile.FindType(arg, traceLine);
TemplateNode templateNode = new TemplateNode();
templateNode.ArgBundle = a2;
templateNode.Name = a2.MacroVariableName;
switch (node.EncodingType)
{
case CLogEncodingType.Int32:
templateNode.Type = "win:Int32";
templateNode.Hash = "i32_";
break;
case CLogEncodingType.UInt32:
templateNode.Type = "win:UInt32";
templateNode.Hash = "ui32_";
break;
case CLogEncodingType.Int64:
templateNode.Type = "win:Int64";
templateNode.Hash = "i64_";
break;
case CLogEncodingType.UInt64:
templateNode.Type = "win:UInt64";
templateNode.Hash = "ui64_";
break;
case CLogEncodingType.ANSI_String:
templateNode.Type = "win:AnsiString";
templateNode.Hash = "sz_";
break;
case CLogEncodingType.UNICODE_String:
templateNode.Type = "win:UnicodeString";
templateNode.Hash = "usz_";
break;
case CLogEncodingType.GUID:
templateNode.Type = "win:GUID";
templateNode.Hash = "g_";
break;
case CLogEncodingType.Pointer:
templateNode.Type = "win:Pointer";
templateNode.Hash = "ptr_";
break;
case CLogEncodingType.UInt16:
templateNode.Type = "win:UInt16";
templateNode.Hash = "ui16_";
break;
case CLogEncodingType.Int16:
templateNode.Type = "win:Int16";
templateNode.Hash = "i16_";
break;
case CLogEncodingType.UInt8:
templateNode.Type = "win:UInt8";
templateNode.Hash = "ui8_";
break;
case CLogEncodingType.Int8:
templateNode.Type = "win:Int8";
templateNode.Hash = "i8_";
break;
case CLogEncodingType.ByteArray:
{
templateNode.Type = "win:UInt8";
templateNode.Hash = "ui8_";
templateNode.Name += "_len";
listOfTemplateArgs.Add(templateNode);
templateNode = new TemplateNode();
templateNode.ArgBundle = a2;
templateNode.Name = a2.MacroVariableName;
templateNode.LengthOfSelf = arg.MacroVariableName + "_len";
templateNode.Type = "win:Binary";
templateNode.Hash = "binary_";
}
break;
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.Skip:
continue;
default:
throw new Exception("Unknown Type: " + node);
}
listOfTemplateArgs.Add(templateNode);
}
return(listOfTemplateArgs);
}
public CLogEncodingCLogTypeSearch FindType(CLogFileProcessor.CLogVariableBundle bundle, CLogDecodedTraceLine traceLineMatch)
{
return(FindType(bundle, traceLineMatch.match));
}
public void TraceLineDiscovered(string sourceFile, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline, StringBuilder function)
{
//string priority = decodedTraceLine.GetConfigurationValue(ModuleName, "Priority");
string clean;
CLogFileProcessor.CLogTypeContainer[] types = CLogFileProcessor.BuildTypes(decodedTraceLine.configFile, null, decodedTraceLine.TraceString, null, out clean);
string printf = "";
foreach (var t in types)
{
printf += t.LeadingString;
switch (t.TypeNode.EncodingType)
{
case CLogEncodingType.Int32:
printf += "%d";
break;
case CLogEncodingType.UInt32:
printf += "%u";
break;
case CLogEncodingType.Int64:
printf += "%lld";
break;
case CLogEncodingType.UInt64:
printf += "%llu";
break;
case CLogEncodingType.ANSI_String:
printf += "%s";
break;
case CLogEncodingType.UNICODE_String:
printf += "%p";
break;
case CLogEncodingType.Pointer:
printf += "%p";
break;
case CLogEncodingType.GUID:
printf += "%p";
break;
case CLogEncodingType.Int16:
printf += "%d";
break;
case CLogEncodingType.UInt16:
printf += "%d";
break;
case CLogEncodingType.Int8:
printf += "%d";
break;
case CLogEncodingType.UInt8:
printf += "%d";
break;
case CLogEncodingType.ByteArray:
printf += "%p";
break;
}
}
if (types.Length >= 1)
{
string tail = decodedTraceLine.TraceString.Substring(types[types.Length - 1].ArgStartingIndex + types[types.Length - 1].ArgLength);
printf += tail;
}
inline.Append($"printf(\"{printf}\\r\\n\"");
for (int i = 0; i < decodedTraceLine.splitArgs.Length; ++i)
{
string cast = "";
switch (types[i].TypeNode.EncodingType)
{
case CLogEncodingType.Int32:
cast = "(int)";
break;
case CLogEncodingType.UInt32:
cast = "(unsigned int)";
break;
case CLogEncodingType.Int64:
cast = "(__int64)";
break;
case CLogEncodingType.UInt64:
cast = "(unsigned __int64)";
break;
case CLogEncodingType.ANSI_String:
break;
case CLogEncodingType.UNICODE_String:
throw new NotImplementedException("UNICODE NOT SUPPORTED");
case CLogEncodingType.Pointer:
cast = "(void*)";
break;
case CLogEncodingType.GUID:
cast = "(void*)";
break;
case CLogEncodingType.Int16:
cast = "(__int16)";
break;
case CLogEncodingType.UInt16:
cast = "(unsigned __int16)";
break;
case CLogEncodingType.Int8:
cast = "(int)";
break;
case CLogEncodingType.UInt8:
cast = "(int)";
break;
case CLogEncodingType.ByteArray:
cast = "(void*)";
break;
}
inline.Append($", {cast}(" + decodedTraceLine.splitArgs[i].MacroVariableName + ")");
}
inline.Append(");\\\n");
}
