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"); }