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 FindTypeAndAdvance(string encoded, CLogLineMatch traceLineMatch, ref int index) { int tempIndex = index; CLogEncodingCLogTypeSearch ret = null; if (null != (ret = TypeEncoders.FindTypeAndAdvance(encoded, traceLineMatch, ref tempIndex))) { InUseTypeEncoders.AddType(ret); index = tempIndex; return(ret); } foreach (var config in ChainedConfigurations) { tempIndex = index; if (null != (ret = config.TypeEncoders.FindTypeAndAdvance(encoded, traceLineMatch, ref tempIndex))) { InUseTypeEncoders.AddType(ret); index = tempIndex; return(ret); } } throw new CLogTypeNotFoundException("InvalidType:" + encoded, encoded, traceLineMatch); }
public bool Decode(CLogEncodingCLogTypeSearch type, IClogEventArg value, CLogLineMatch traceLine, out string decodedValue) { // // Compiling also caches the assembly // PrepareAssemblyCompileIfNecessary(); object[] args = new object[1]; switch (type.EncodingType) { case CLogEncodingType.UInt32: args[0] = value.AsUInt32; break; case CLogEncodingType.Int32: args[0] = value.AsInt32; break; case CLogEncodingType.ByteArray: args[0] = value.AsBinary; break; case CLogEncodingType.Pointer: args[0] = value.AsPointer; break; default: throw new NotImplementedException("UndefinedType:" + type); } string customDecoder = type.CustomDecoder; string[] bits = customDecoder.Split('.'); string member = bits[bits.Length - 1]; customDecoder = customDecoder.Substring(0, customDecoder.Length - member.Length - 1); var newType = _codeAssembly.GetType(customDecoder); var instance = _typesInterface = _codeAssembly.CreateInstance(customDecoder); decodedValue = "ERROR:" + type.CustomDecoder; if (!_compiledConverterFunctions.ContainsKey(type.CustomDecoder)) { if (null == newType) { return(true); } var meth = newType.GetMember(member).FirstOrDefault() as MethodInfo; _compiledConverterFunctions[type.CustomDecoder] = meth; } MethodInfo method = _compiledConverterFunctions[type.CustomDecoder]; decodedValue = (string)method.Invoke(_typesInterface, args); return(false); }
public void AddType(CLogEncodingCLogTypeSearch cLogTypeSearch) { bool isNew = false; AddType(_parent, null, cLogTypeSearch, ref isNew); #if false if (isNew) { if (!TypeEncoder.Contains(cLogTypeSearch)) { TypeEncoder.Add(cLogTypeSearch); } } #endif }
public CLogEncodingCLogTypeSearch FindTypeAndAdvance(string encoded, CLogLineMatch traceLineMatch, ref int index) { int tempIndex = index; CLogEncodingCLogTypeSearch ret = null; // // First scan the type encoders in our main config file // if (null != (ret = TypeEncoders.FindTypeAndAdvance(encoded, traceLineMatch, ref tempIndex))) { InUseTypeEncoders.AddType(ret); index = tempIndex; return(ret); } // // If we're unable to locate the type, iterate across each of our chained configs - note this is // recursive; such allowing for heirarchies // foreach (var config in ChainedConfigurations) { tempIndex = index; if (null != (ret = config.FindTypeAndAdvance(encoded, traceLineMatch, ref tempIndex))) { InUseTypeEncoders.AddType(ret); index = tempIndex; return(ret); } } // // Attempt to get something for the user about the actual arg; note this may be error prone as we are now confused // by their inputs // string surroundingArray = encoded.Substring(index, 15); int end = surroundingArray.IndexOf("}"); if (-1 != end) { surroundingArray = surroundingArray.Substring(0, end); } throw new CLogTypeNotFoundException(encoded, "InvalidType:" + surroundingArray, traceLineMatch); }
public bool DecodeUsingCustomDecoder(CLogEncodingCLogTypeSearch node, IClogEventArg value, CLogLineMatch traceLine, out string decodedValue) { if (!TypeEncoders.DecodeUsingCustomDecoder(node, value, traceLine, out decodedValue)) { return(false); } foreach (var config in ChainedConfigurations) { if (!config.DecodeUsingCustomDecoder(node, value, traceLine, out decodedValue)) { return(false); } } decodedValue = "ERROR:CustomDecoderNotFound:" + node.CustomDecoder + ":" + node.DefinationEncoding; return(false); }
private string ConvertToClogType(CLogEncodingCLogTypeSearch node) { switch (node.EncodingType) { case CLogEncodingType.Int8: return("char"); case CLogEncodingType.UInt8: return("unsigned char"); case CLogEncodingType.Int32: return("int"); case CLogEncodingType.UInt32: return("unsigned int"); case CLogEncodingType.Int64: return("long long"); case CLogEncodingType.UInt64: return("unsigned long long"); case CLogEncodingType.Pointer: return("const void *"); case CLogEncodingType.Int16: return("short"); case CLogEncodingType.UInt16: return("unsigned short"); case CLogEncodingType.ByteArray: return("const void *"); case CLogEncodingType.ANSI_String: return("const char *"); default: throw new CLogEnterReadOnlyModeException("InvalidType:" + node.EncodingType, CLogHandledException.ExceptionType.EncoderIncompatibleWithType, null); } }
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 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; })); }
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 void AddType(CLogTypeSearchNode searchNode, CLogTypeSearchNode parentNode, CLogEncodingCLogTypeSearch fileNode, ref bool isNew, int index = 0) { if (index == fileNode.DefinationEncoding.Length) { searchNode.UserNode = fileNode; return; } CLogTypeSearchNode n; if (!searchNode.Nodes.TryGetValue(fileNode.DefinationEncoding[index], out n)) { searchNode.Nodes[fileNode.DefinationEncoding[index]] = n = new CLogTypeSearchNode(); isNew = true; } AddType(n, searchNode, fileNode, ref isNew, index + 1); }
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 static CLogVariableBundle CreateVariableBundle(VariableInfo i, string definationEncoding, CLogEncodingCLogTypeSearch typeNode) { CLogVariableBundle b = new CLogVariableBundle(); b.VariableInfo = i; b.DefinationEncoding = definationEncoding; return(b); }
public void AddConverter(CLogEncodingCLogTypeSearch type) { _converterFunctions[type.DefinationEncoding] = type; }
public bool DecodeUsingCustomDecoder(CLogEncodingCLogTypeSearch node, IClogEventArg value, CLogLineMatch traceLine, out string decodedValue) { return(_traceEmittorX.Decode(node, value, traceLine, out decodedValue)); }
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); }