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 CLogEncodingCLogTypeSearch FindTypeX(CLogFileProcessor.CLogVariableBundle bundle, CLogLineMatch traceLineMatch)
{
int idx = 0;
return(_sideCarFile.ConfigFile.FindTypeAndAdvance(bundle.DefinationEncoding, traceLineMatch, ref idx));
}
public CLogEncodingCLogTypeSearch FindType(CLogFileProcessor.CLogVariableBundle bundle, CLogDecodedTraceLine traceLineMatch)
{
return(FindType(bundle, traceLineMatch.match));
}
public CLogEncodingCLogTypeSearch FindTypeX(CLogFileProcessor.CLogVariableBundle bundle)
{
return(FindTypeX(bundle.DefinationEncoding));
}
public CLogEncodingCLogTypeSearch FindType(CLogFileProcessor.CLogVariableBundle bundle)
{
return(FindType(bundle, (CLogLineMatch)null));
}
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 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 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)
{
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);
}
