public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var messages = tableData.QueryOutput <IReadOnlyList <IDiagnosticMessage> >(
DataOutputPath.Create(LTTngDmesgDataCooker.CookerPath + "/DiagnosticMessages"));
if (messages.Count == 0)
{
return;
}
var config = new TableConfiguration("MessagesByTimestamp")
{
Columns = new[]
{
messageColumn,
TableConfiguration.PivotColumn,
TableConfiguration.GraphColumn,
timestampColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
config.AddColumnRole(ColumnRole.StartTime, timestampColumn);
config.AddColumnRole(ColumnRole.EndTime, timestampColumn);
var table = tableBuilder.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(messages.Count);
table.AddColumn(messageColumn, Projection.CreateUsingFuncAdaptor((i) => messages[i].Message));
table.AddColumn(timestampColumn, Projection.CreateUsingFuncAdaptor((i) => messages[i].Timestamp));
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
WaLinuxAgentLogParsedResult parsedResult = tableData.QueryOutput <WaLinuxAgentLogParsedResult>(
DataOutputPath.Create(SourceParserIds.WaLinuxAgentLog, WaLinuxAgentDataCooker.CookerId, "ParsedResult"));
var logEntries = parsedResult.LogEntries;
var baseProjection = Projection.Index(logEntries);
var fileNameProjection = baseProjection.Compose(x => x.FilePath);
var lineNumberProjection = baseProjection.Compose(x => x.LineNumber);
var eventTimeProjection = baseProjection.Compose(x => x.EventTimestamp);
var logLevelProjection = baseProjection.Compose(x => x.LogLevel);
var logProjection = baseProjection.Compose(x => x.Log);
//
// Table Configurations describe how your table should be presented to the user:
// the columns to show, what order to show them, which columns to aggregate, and which columns to graph.
// You may provide a number of columns in your table, but only want to show a subset of them by default so as not to overwhelm the user.
// The user can still open the table properties in UI to turn on or off columns.
// The table configuration class also exposes four (4) columns that UI explicitly recognizes: Pivot Column, Graph Column, Left Freeze Column, Right Freeze Column
// For more information about what these columns do, go to "Advanced Topics" -> "Table Configuration" in our Wiki. Link can be found in README.md
//
var config = new TableConfiguration("Default")
{
Columns = new[]
{
LogLevelColumn,
TableConfiguration.PivotColumn,
LineNumberColumn,
LogColumn,
EventTimestampDateTimeColumn,
TableConfiguration.GraphColumn,
EventTimestampColumn,
},
Layout = TableLayoutStyle.GraphAndTable,
};
config.AddColumnRole(ColumnRole.StartTime, EventTimestampColumn);
//
//
// Use the table builder to build the table.
// Add and set table configuration if applicable.
// Then set the row count (we have one row per file) and then add the columns using AddColumn.
//
tableBuilder
.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(logEntries.Count)
.AddColumn(FileNameColumn, fileNameProjection)
.AddColumn(LineNumberColumn, lineNumberProjection)
.AddColumn(EventTimestampColumn, eventTimeProjection)
.AddColumn(LogLevelColumn, logLevelProjection)
.AddColumn(LogColumn, logProjection);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var threads = tableData.QueryOutput <IReadOnlyList <IThread> >(
DataOutputPath.Create(LTTngThreadDataCooker.CookerPath + "/Threads"));
if (threads.Count == 0)
{
return;
}
var config = new TableConfiguration("ThreadsByProcessId")
{
Columns = new[]
{
processIdColumn,
threadIdColumn,
commandColumn,
TableConfiguration.PivotColumn,
threadExecTimeColumn,
threadReadyTimeColumn,
threadRunningTimeColumn,
threadSleepTimeColumn,
threadDiskSleepTimeColumn,
threadWaitingTimeColumn,
threadIdleTimeColumn,
TableConfiguration.GraphColumn,
threadStartTimeColumn,
threadExitTimeColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
config.AddColumnRole(ColumnRole.StartTime, threadStartTimeColumn);
config.AddColumnRole(ColumnRole.EndTime, threadExitTimeColumn);
var table = tableBuilder.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(threads.Count);
table.AddColumn(threadIdColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ThreadId));
table.AddColumn(processIdColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ProcessId));
table.AddColumn(commandColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].Command));
table.AddColumn(threadExecTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ExecTime));
table.AddColumn(threadReadyTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ReadyTime));
table.AddColumn(threadRunningTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ExecTime + threads[i].ReadyTime));
table.AddColumn(threadSleepTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].SleepTime));
table.AddColumn(threadDiskSleepTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].DiskSleepTime));
table.AddColumn(threadWaitingTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].SleepTime + threads[i].DiskSleepTime));
table.AddColumn(threadStoppedTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].StoppedTime));
table.AddColumn(threadParkedTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ParkedTime));
table.AddColumn(threadIdleTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].IdleTime));
table.AddColumn(threadStartTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].StartTime));
table.AddColumn(threadExitTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ExitTime));
table.AddColumn(threadLifespanColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ExitTime - threads[i].StartTime));
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
CloudInitLogParsedResult parsedResult = tableData.QueryOutput <CloudInitLogParsedResult>(
DataOutputPath.Create(SourceParserIds.CloudInitLog, CloudInitDataCooker.CookerId, "ParsedResult"));
var logEntries = parsedResult.LogEntries;
var baseProjection = Projection.Index(logEntries);
var fileNameProjection = baseProjection.Compose(x => x.FilePath);
var lineNumberProjection = baseProjection.Compose(x => x.LineNumber);
var eventTimeProjection = baseProjection.Compose(x => x.EventTimestamp);
var pythonFileProjection = baseProjection.Compose(x => x.PythonFile);
var logLevelProjection = baseProjection.Compose(x => x.LogLevel);
var logProjection = baseProjection.Compose(x => x.Log);
var config = new TableConfiguration("Default")
{
Columns = new[]
{
FileNameColumn,
LogLevelColumn,
TableConfiguration.PivotColumn,
PythonFileColumn,
LineNumberColumn,
LogColumn,
EventTimestampDateTimeColumn,
TableConfiguration.GraphColumn,
EventTimestampColumn,
},
Layout = TableLayoutStyle.GraphAndTable,
};
config.AddColumnRole(ColumnRole.StartTime, EventTimestampColumn);
//
//
// Use the table builder to build the table.
// Add and set table configuration if applicable.
// Then set the row count (we have one row per file) and then add the columns using AddColumn.
//
tableBuilder
.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(logEntries.Count)
.AddColumn(FileNameColumn, fileNameProjection)
.AddColumn(LineNumberColumn, lineNumberProjection)
.AddColumn(EventTimestampColumn, eventTimeProjection)
.AddColumn(PythonFileColumn, pythonFileProjection)
.AddColumn(LogLevelColumn, logLevelProjection)
.AddColumn(LogColumn, logProjection)
;
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
DmesgIsoLogParsedResult parsedResult = tableData.QueryOutput <DmesgIsoLogParsedResult>(
DataOutputPath.Create(SourceParserIds.DmesgIsoLog, DmesgIsoDataCooker.CookerId, "ParsedResult"));
var fileNames = parsedResult.FileToMetadata.Keys.ToArray();
var fileNameProjection = Projection.Index(fileNames.AsReadOnly());
var lineCountProjection = fileNameProjection.Compose(
fileName => parsedResult.FileToMetadata[fileName].LineCount);
tableBuilder.SetRowCount(fileNames.Length)
.AddColumn(FileNameColumn, fileNameProjection)
.AddColumn(LineCountColumn, lineCountProjection);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var syscalls = tableData.QueryOutput <IReadOnlyList <ISyscall> >(
DataOutputPath.Create(LTTngSyscallDataCooker.CookerPath + '/' + nameof(LTTngSyscallDataCooker.Syscalls)));
if (syscalls.Count == 0)
{
return;
}
var defaultConfig = new TableConfiguration("Individual Syscalls")
{
Columns = new[]
{
syscallNumberColumn,
TableConfiguration.PivotColumn,
syscallNameColumn,
syscallDurationColumn,
syscallArgumentsColumn,
syscallReturnValueColumn,
syscallThreadIdColumn,
syscallCommandColumn,
syscallProcessIdColumn,
TableConfiguration.GraphColumn,
syscallStartTimeColumn,
syscallEndTimeColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
defaultConfig.AddColumnRole(ColumnRole.StartTime, syscallStartTimeColumn);
defaultConfig.AddColumnRole(ColumnRole.EndTime, syscallEndTimeColumn);
var table = tableBuilder.AddTableConfiguration(defaultConfig)
.SetDefaultTableConfiguration(defaultConfig)
.SetRowCount(syscalls.Count);
table.AddColumn(syscallNameColumn, Projection.CreateUsingFuncAdaptor((i) => syscalls[i].Name));
table.AddColumn(syscallThreadIdColumn, Projection.CreateUsingFuncAdaptor((i) => syscalls[i].ThreadId));
table.AddColumn(syscallProcessIdColumn, Projection.CreateUsingFuncAdaptor((i) => syscalls[i].ProcessId));
table.AddColumn(syscallCommandColumn, Projection.CreateUsingFuncAdaptor((i) => syscalls[i].ProcessCommand));
table.AddColumn(syscallNumberColumn, Projection.CreateUsingFuncAdaptor((i) => i + 1));
table.AddColumn(syscallStartTimeColumn, Projection.CreateUsingFuncAdaptor((i) => syscalls[i].StartTime));
table.AddColumn(syscallEndTimeColumn, Projection.CreateUsingFuncAdaptor((i) => syscalls[i].EndTime));
table.AddColumn(syscallDurationColumn, Projection.CreateUsingFuncAdaptor((i) => syscalls[i].EndTime - syscalls[i].StartTime));
table.AddColumn(syscallReturnValueColumn, Projection.CreateUsingFuncAdaptor((i) => syscalls[i].ReturnValue));
table.AddColumn(syscallArgumentsColumn, Projection.CreateUsingFuncAdaptor((i) => syscalls[i].Arguments));
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
DmesgIsoLogParsedResult parsedResult = tableData.QueryOutput <DmesgIsoLogParsedResult>(
DataOutputPath.Create(SourceParserIds.DmesgIsoLog, DmesgIsoDataCooker.CookerId, "ParsedResult"));
var logEntries = parsedResult.LogEntries;
var baseProjection = Projection.Index(logEntries);
var fileNameProjection = baseProjection.Compose(x => x.filePath);
var lineNumberProjection = baseProjection.Compose(x => x.lineNumber);
var entityProjection = baseProjection.Compose(x => x.entity);
var topicProjection = baseProjection.Compose(x => x.topic);
var timestampProjection = baseProjection.Compose(x => x.timestamp);
var metadataProjection = baseProjection.Compose(x => x.metadata);
var messageProjection = baseProjection.Compose(x => x.message);
var config = new TableConfiguration("Default")
{
Columns = new[]
{
FileNameColumn,
EntityColumn,
TableConfiguration.PivotColumn,
MessageNumberColumn,
TopicColumn,
MessageColumn,
MetadataColumn,
TableConfiguration.GraphColumn,
TimestampColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
config.AddColumnRole(ColumnRole.StartTime, TimestampColumn);
config.AddColumnRole(ColumnRole.EndTime, TimestampColumn);
tableBuilder.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(logEntries.Count)
.AddColumn(FileNameColumn, fileNameProjection)
.AddColumn(MessageNumberColumn, lineNumberProjection)
.AddColumn(EntityColumn, entityProjection)
.AddColumn(TopicColumn, topicProjection)
.AddColumn(MessageColumn, messageProjection)
.AddColumn(TimestampColumn, timestampProjection)
.AddColumn(MetadataColumn, metadataProjection);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var fileEvents = tableData.QueryOutput <IReadOnlyList <IFileEvent> >(
DataOutputPath.Create(LTTngDiskDataCooker.CookerPath + '/' + nameof(LTTngDiskDataCooker.FileEvents)));
if (fileEvents.Count == 0)
{
return;
}
var config = new TableConfiguration("EventsBySyscallType")
{
Columns = new[]
{
fileEventNameColumn,
TableConfiguration.PivotColumn,
fileEventThreadIdColumn,
fileEventProcessIdColumn,
fileEventCommandColumn,
fileEventFilePathColumn,
fileEventSizeColumn,
fileEventDurationColumn,
TableConfiguration.GraphColumn,
fileEventStartTimeColumn,
fileEventEndTimeColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
config.AddColumnRole(ColumnRole.StartTime, fileEventStartTimeColumn);
config.AddColumnRole(ColumnRole.EndTime, fileEventEndTimeColumn);
var table = tableBuilder.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(fileEvents.Count);
table.AddColumn(fileEventNameColumn, Projection.CreateUsingFuncAdaptor((i) => fileEvents[i].Name));
table.AddColumn(fileEventThreadIdColumn, Projection.CreateUsingFuncAdaptor((i) => fileEvents[i].ThreadId));
table.AddColumn(fileEventProcessIdColumn, Projection.CreateUsingFuncAdaptor((i) => fileEvents[i].ProcessId));
table.AddColumn(fileEventCommandColumn, Projection.CreateUsingFuncAdaptor((i) => fileEvents[i].ProcessCommand));
table.AddColumn(fileEventFilePathColumn, Projection.CreateUsingFuncAdaptor((i) => fileEvents[i].Filepath));
table.AddColumn(fileEventStartTimeColumn, Projection.CreateUsingFuncAdaptor((i) => fileEvents[i].StartTime));
table.AddColumn(fileEventEndTimeColumn, Projection.CreateUsingFuncAdaptor((i) => fileEvents[i].EndTime));
table.AddColumn(fileEventDurationColumn, Projection.CreateUsingFuncAdaptor((i) => fileEvents[i].EndTime - fileEvents[i].StartTime));
table.AddColumn(fileEventSizeColumn, new FileActivitySizeProjection(Projection.CreateUsingFuncAdaptor((i) => fileEvents[i])));
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var moduleEvents = tableData.QueryOutput <IReadOnlyList <IModuleEvent> >(
DataOutputPath.Create(LTTngModuleDataCooker.CookerPath + '/' + nameof(LTTngModuleDataCooker.ModuleEvents)));
if (moduleEvents.Count == 0)
{
return;
}
var defaultConfig = new TableConfiguration("Module Events")
{
Columns = new[]
{
moduleNameColumn,
eventTypeColumn,
TableConfiguration.PivotColumn,
instructionPointerColumn,
refCountColumn,
threadIdColumn,
processIdColumn,
commandColumn,
TableConfiguration.GraphColumn,
timestampColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
defaultConfig.AddColumnRole(ColumnRole.StartTime, timestampColumn);
defaultConfig.AddColumnRole(ColumnRole.EndTime, timestampColumn);
var table = tableBuilder.AddTableConfiguration(defaultConfig)
.SetDefaultTableConfiguration(defaultConfig)
.SetRowCount(moduleEvents.Count);
table.AddColumn(eventTypeColumn, Projection.CreateUsingFuncAdaptor((i) => moduleEvents[i].EventType));
table.AddColumn(moduleNameColumn, Projection.CreateUsingFuncAdaptor((i) => moduleEvents[i].ModuleName));
table.AddColumn(instructionPointerColumn, Projection.CreateUsingFuncAdaptor((i) => moduleEvents[i].InstructionPointer));
table.AddColumn(refCountColumn, Projection.CreateUsingFuncAdaptor((i) => moduleEvents[i].RefCount));
table.AddColumn(threadIdColumn, Projection.CreateUsingFuncAdaptor((i) => moduleEvents[i].ThreadId));
table.AddColumn(processIdColumn, Projection.CreateUsingFuncAdaptor((i) => moduleEvents[i].ProcessId));
table.AddColumn(commandColumn, Projection.CreateUsingFuncAdaptor((i) => moduleEvents[i].ProcessCommand));
table.AddColumn(timestampColumn, Projection.CreateUsingFuncAdaptor((i) => moduleEvents[i].Time));
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var contextSwitches = tableData.QueryOutput <ProcessedEventData <IContextSwitch> >(
DataOutputPath.Create("LTTng/CpuDataCooker/ContextSwitches"));
if (contextSwitches.Count == 0)
{
return;
}
var table = tableBuilder.SetRowCount((int)contextSwitches.Count);
table.AddColumn(oldThreadIdColumn, Projection.CreateUsingFuncAdaptor((i) => contextSwitches[(uint)i].SwitchOut.ThreadId));
table.AddColumn(oldImageNameColumn, Projection.CreateUsingFuncAdaptor((i) => contextSwitches[(uint)i].SwitchOut.ImageName));
table.AddColumn(oldPriorityColumn, Projection.CreateUsingFuncAdaptor((i) => contextSwitches[(uint)i].SwitchOut.Priority));
table.AddColumn(newThreadIdColumn, Projection.CreateUsingFuncAdaptor((i) => contextSwitches[(uint)i].SwitchIn.ThreadId));
table.AddColumn(newImageNameColumn, Projection.CreateUsingFuncAdaptor((i) => contextSwitches[(uint)i].SwitchIn.ImageName));
table.AddColumn(newPriorityColumn, Projection.CreateUsingFuncAdaptor((i) => contextSwitches[(uint)i].SwitchIn.Priority));
table.AddColumn(timestampColumn, Projection.CreateUsingFuncAdaptor((i) => contextSwitches[(uint)i].Timestamp));
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
int maximumFieldCount = tableData.QueryOutput <int>(
DataOutputPath.Create("Perf/GenericEvents/MaximumEventFieldCount"));
var events = tableData.QueryOutput <ProcessedEventData <PerfGenericEvent> >(
DataOutputPath.Create("Perf/GenericEvents/Events"));
var tableGenerator = tableBuilder.SetRowCount((int)events.Count);
var genericEventProjection = new GenericEventProjection(events);
var eventNameColumn = new BaseDataColumn <string>(
eventNameColumnConfig,
genericEventProjection.Compose((genericEvent) => genericEvent.EventName));
tableGenerator.AddColumn(eventNameColumn);
var eventIdColumn = new BaseDataColumn <uint>(
eventIdColumnConfig,
genericEventProjection.Compose((genericEvent) => genericEvent.Id));
tableGenerator.AddColumn(eventIdColumn);
var cpuIdColumn = new BaseDataColumn <uint>(
cpuIdColumnConfig,
genericEventProjection.Compose((genericEvent) => genericEvent.CpuId));
tableGenerator.AddColumn(cpuIdColumn);
var eventTimestampColumn = new BaseDataColumn <Timestamp>(
eventTimestampColumnConfig,
genericEventProjection.Compose((genericEvent) => genericEvent.Timestamp));
tableGenerator.AddColumn(eventTimestampColumn);
tableGenerator.AddColumn(countColumnConfig, Projection.Constant(1));
// Add the field columns, with column names depending on the given event
for (int columnIndex = 0; columnIndex < maximumFieldCount; columnIndex++)
{
string fieldName = "Field " + (columnIndex + 1);
var genericEventFieldProjection = new GenericEventFieldProjection(columnIndex, genericEventProjection);
var genericEventFieldNameProjection =
genericEventFieldProjection.Compose((field) => field.HasValue ? field.Value.Name : string.Empty);
// generate a column configuration
var fieldColumnConfiguration = new ColumnConfiguration(
new ColumnMetadata(GenerateGuidFromName(fieldName), fieldName, genericEventFieldNameProjection, fieldName),
new UIHints
{
IsVisible = true,
Width = 80,
TextAlignment = TextAlignment.Left,
});
var genericEventFieldAsStringProjection =
genericEventFieldProjection.Compose((field) => field.HasValue ? field.Value.Value : string.Empty);
tableGenerator.AddColumn(fieldColumnConfiguration, genericEventFieldAsStringProjection);
}
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var diskEvents = tableData.QueryOutput <IReadOnlyList <IDiskActivity> >(
DataOutputPath.Create(LTTngDiskDataCooker.CookerPath + '/' + nameof(LTTngDiskDataCooker.DiskActivity)));
if (diskEvents.Count == 0)
{
return;
}
var iosByDeviceThCmdConfig = new TableConfiguration("IOs by Device, ThreadId, Command")
{
Columns = new[]
{
deviceIdColumn,
deviceNameColumn,
threadIdColumn,
commandColumn,
TableConfiguration.PivotColumn,
processIdColumn,
filepathColumn,
ioTimeSumColumn,
sectorNumberColumn,
diskOffsetColumn,
sizeColumn,
errorColumn,
TableConfiguration.GraphColumn,
insertTimeColumn,
issueTimeColumn,
completeTimeColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
var ioTimesByDevFileConfig = new TableConfiguration("IOTime by Device, FilePath")
{
Columns = new[]
{
deviceIdColumn,
deviceNameColumn,
TableConfiguration.PivotColumn,
filepathColumn,
threadIdColumn,
processIdColumn,
commandColumn,
sectorNumberColumn,
diskOffsetColumn,
sizeColumn,
errorColumn,
insertTimeColumn,
issueTimeColumn,
completeTimeColumn,
TableConfiguration.GraphColumn,
ioTimeAvgColumn,
ioTimeMaxColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
iosByDeviceThCmdConfig.AddColumnRole(ColumnRole.StartTime, insertTimeColumn);
// config.AddColumnRole(ColumnRole.EndTime, completeTimeColumn);
iosByDeviceThCmdConfig.AddColumnRole(ColumnRole.ResourceId, deviceIdColumn); // We have had past behavior where specifying this causes DevId 0 not to show?
var table = tableBuilder.AddTableConfiguration(iosByDeviceThCmdConfig)
.AddTableConfiguration(ioTimesByDevFileConfig)
.SetDefaultTableConfiguration(iosByDeviceThCmdConfig)
.SetRowCount((int)diskEvents.Count);
var diskActivities = Projection.CreateUsingFuncAdaptor((i) => diskEvents[i]);
var defaultTime = default(Timestamp);
var ioStartTimeProjection = diskActivities.Compose(da => da.InsertTime ?? defaultTime);
var ioEndTimeProjection = diskActivities.Compose(da => da.CompleteTime ?? defaultTime);
var validIoTimeProjection =
diskActivities.Compose(da => da.InsertTime.HasValue && da.CompleteTime.HasValue);
table.AddColumn(deviceIdColumn, diskActivities.Compose(da => da.DeviceId));
table.AddColumn(deviceNameColumn, diskActivities.Compose(da => da.DeviceName));
table.AddColumn(filepathColumn, diskActivities.Compose(da => da.Filepath));
table.AddColumn(threadIdColumn, diskActivities.Compose(da => da.ThreadId));
table.AddColumn(processIdColumn, diskActivities.Compose(da => da.ProcessId));
table.AddColumn(commandColumn, diskActivities.Compose(da => da.ProcessCommand));
table.AddColumn(errorColumn, diskActivities.Compose(da => da.Error));
table.AddColumn(ioTimeIsValidColumnConfiguration, validIoTimeProjection);
table.AddColumn(sectorNumberColumn, diskActivities.Compose(da => da.SectorNumber));
// todo:can we pick up the sector size from the trace?
table.AddColumn(diskOffsetColumn, diskActivities.Compose(da => new Bytes(da.SectorNumber * 512)));
table.AddColumn(insertTimeColumn, ioStartTimeProjection);
table.AddColumn(issueTimeColumn, diskActivities.Compose(da => da.IssueTime ?? defaultTime));
table.AddColumn(completeTimeColumn, ioEndTimeProjection);
var diskActivitiesProj = diskActivities.Compose((da) =>
{
if (da.CompleteTime.HasValue)
{
if (da.InsertTime.HasValue)
{
return(da.CompleteTime.Value - da.InsertTime.Value);
}
}
return(TimestampDelta.Zero);
});
table.AddColumn(ioTimeAvgColumn, diskActivitiesProj);
{
IProjection <int, Timestamp> viewportClippedStartTimeColumn =
Projection.ClipTimeToViewport.Create(ioStartTimeProjection);
IProjection <int, Timestamp> viewportClippedEndTimeColumn =
Projection.ClipTimeToViewport.Create(ioEndTimeProjection);
// Timestamp delta for the given disk activity during the viewport time range.
IProjection <int, TimestampDelta> clippedTimeDeltaColumn = Projection.Select(
viewportClippedEndTimeColumn,
viewportClippedStartTimeColumn,
new ReduceTimeSinceLastDiff(validIoTimeProjection));
table.AddColumn(clippedTimestampDeltaColumnConfiguration, clippedTimeDeltaColumn);
// Percent of time consumed by the timestamp delta in the current viewport.
/* IProjection<int, double> ioTimeWeightPercentColumn =
* Projection.ClipTimeToViewport.CreatePercent(clippedTimeDeltaColumn);*/
/// table.AddColumn(weightedIOTimeColumn, ioTimeWeightPercentColumn);
}
table.AddColumn(sizeColumn, new DiskActivitySizeProjection(diskActivities));
// IOCount with no restriction on IOSize - Used to enable some of the graphs in analyzer
table.AddColumn(countColumn, Projection.Constant <int>(1));
// todo: should we move the Azure specific columns here?
// IOCount when IOSize is 8KB (such as in Azure local SSD throttling)
table.AddColumn(countColumn_IOSize8kb, diskActivities.Compose(da => da.Size.HasValue && da.Size.Value.Bytes > 0 ? Math.Ceiling((float)da.Size.Value.Bytes / (8 * 1024)) : 1));
// IOCount when IOSize is 256KB (such as in Azure XStore throttling)
table.AddColumn(countColumn_IOSize256kb, diskActivities.Compose(da => da.Size.HasValue && da.Size.Value.Bytes > 0 ? Math.Ceiling((float)da.Size.Value.Bytes / (256 * 1024)) : 1));
}
public void Process_Isolated_WhenComplete_DataWasProcessed(
EngineProcessTestCaseDto testCase)
{
if (testCase.DebugBreak)
{
System.Diagnostics.Debugger.Break();
}
var runtime = Engine.Create(
new EngineCreateInfo
{
AssemblyLoader = new IsolationAssemblyLoader(),
});
foreach (var cooker in testCase.CookersToEnable)
{
var cookerPath = DataCookerPath.Parse(cooker);
Assert.IsTrue(runtime.TryEnableCooker(cookerPath), "Unable to enable cooker '{0}'", cookerPath);
}
foreach (var file in testCase.FilePaths)
{
runtime.AddFile(file);
}
var results = runtime.Process();
foreach (var expectedData in testCase.ExpectedOutputs)
{
var dataOutputPathRaw = expectedData.Key;
var expectedDataPoints = expectedData.Value;
var dataOutputPath = DataOutputPath.Create(dataOutputPathRaw);
Assert.IsTrue(
results.TryQueryOutput(dataOutputPath, out object data), "Output for {0} not found.", dataOutputPathRaw);
Assert.IsNotNull(data, "output for {0} was null ???", dataOutputPathRaw);
var enumerableData = data as IEnumerable;
Assert.IsNotNull(
enumerableData,
"Test output data must implement IEnumerable<> (type wasn't enumerable): '{0}'",
data.GetType());
var enumerableType = enumerableData.GetType();
var eInterface = enumerableType.GetInterface(typeof(IEnumerable <>).Name);
Assert.IsNotNull(
eInterface,
"Test output data must implement IEnumerable<> (interface wasn't found): {0}",
string.Join(", ", data.GetType().GetInterfaces().Select(x => x.FullName)));
var collectionType = eInterface.GetGenericArguments()[0];
Assert.IsNotNull(collectionType, "Unable to retrieve collection type for {0}", data.GetType());
var enumeratedData = new List <object>();
foreach (var o in enumerableData)
{
enumeratedData.Add(o);
}
Assert.AreEqual(
expectedDataPoints.Length,
enumeratedData.Count,
"The processor did not process the correct amount of data: {0}",
dataOutputPath);
var properties = collectionType.GetProperties()
.ToDictionary(x => x.Name, x => x, StringComparer.InvariantCultureIgnoreCase);
for (var i = 0; i < expectedDataPoints.Length; ++i)
{
var expectedObject = expectedDataPoints[i];
var actualObject = enumeratedData[i];
foreach (var kvp in expectedObject)
{
var propertyName = kvp.Key;
var expectedValue = kvp.Value;
Assert.IsTrue(properties.TryGetValue(propertyName, out PropertyInfo property));
var actualValue = property.GetValue(actualObject)?.ToString();
Assert.AreEqual(expectedValue, actualValue, propertyName);
}
}
}
foreach (var dataOutputPathRaw in testCase.ThrowingOutputs)
{
var dataOutputPath = DataOutputPath.Create(dataOutputPathRaw);
Assert.IsFalse(
results.TryQueryOutput(dataOutputPath, out var _),
"Output should not have been available: {0}",
dataOutputPathRaw);
}
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var pathIdentifier = DataOutputPath.Create(PerfCpuClockDataCooker.CookerPath + "/CpuClockEvents");
var cpuClocks = tableData.QueryOutput <IReadOnlyList <ICpuClockEvent> >(pathIdentifier);
if (cpuClocks.Count == 0)
{
return;
}
var config = new TableConfiguration("CPU Utilization")
{
Columns = new[]
{
cpuColumn,
callStackColumn,
TableConfiguration.PivotColumn,
pidColumn,
threadIdColumn,
ipColumn,
symbolTypeColumn,
ipSymbolColumn,
idColumn,
weightColumn,
countColumn,
timeStampColumn,
TableConfiguration.GraphColumn,
weightPctColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
config.AddColumnRole(ColumnRole.EndTime, timeStampColumn);
config.AddColumnRole(ColumnRole.Duration, weightColumn);
config.AddColumnRole(ColumnRole.ResourceId, cpuColumn);
var table = tableBuilder.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(cpuClocks.Count);
var timeStampProjection = Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Timestamp);
table.AddColumn(cpuColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Cpu));
table.AddColumn(ipColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Ip));
table.AddColumn(symbolTypeColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Ip_Symbol?.SymbolType?.SymbolTypeDescription.SymbolTypeShortName));
table.AddColumn(ipSymbolColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Ip_Symbol?.Name));
table.AddColumn(threadIdColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Tid));
table.AddColumn(pidColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Pid));
table.AddColumn(idColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Id));
table.AddColumn(perfPeriodColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Perf_Period));
table.AddColumn(perfCallchainSizeColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Perf_Callchain_Size));
table.AddHierarchicalColumn(callStackColumn, Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].CallStack), new ArrayAccessProvider <string>());
table.AddColumn(timeStampColumn, timeStampProjection);
var oneMsSample = new TimestampDelta(1000000); // 1ms for now until we can figure out weight better
var oneNs = new TimestampDelta(1);
var weightProj = Projection.Constant(oneMsSample);
var timeStampStartProjection = Projection.CreateUsingFuncAdaptor((i) => cpuClocks[i].Timestamp - oneNs); // We will say sample lasted 1ns
IProjection <int, Timestamp> viewportClippedStartTimeProj = Projection.ClipTimeToViewport.Create(timeStampStartProjection);
IProjection <int, Timestamp> viewportClippedEndTimeProj = Projection.ClipTimeToViewport.Create(timeStampProjection);
IProjection <int, TimestampDelta> clippedWeightProj = Projection.Select(
viewportClippedEndTimeProj,
viewportClippedStartTimeProj,
new ReduceTimeSinceLastDiff());
IProjection <int, double> weightPercentProj = Projection.ViewportRelativePercent.Create(clippedWeightProj);
IProjection <int, int> countProj = SequentialGenerator.Create(
cpuClocks.Count,
Projection.Constant(1),
Projection.Constant(0));
table.AddColumn(weightColumn, weightProj);
table.AddColumn(countColumn, countProj);
table.AddColumn(weightPctColumn, weightPercentProj);
table.AddColumn(startTimeCol, timeStampStartProjection);
table.AddColumn(viewportClippedStartTimeCol, viewportClippedStartTimeProj);
table.AddColumn(viewportClippedEndTimeCol, viewportClippedEndTimeProj);
table.AddColumn(clippedWeightCol, clippedWeightProj);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var threads = tableData.QueryOutput <IReadOnlyList <IExecutionEvent> >(
DataOutputPath.Create(LTTngThreadDataCooker.CookerPath + "/ExecutionEvents"));
if (threads.Count == 0)
{
return;
}
const string filterIdleSamplesQuery = "[New Thread Id]:=\"0\"";
var timelineByCPUTableConfig = new TableConfiguration("Timeline by CPU")
{
Columns = new[]
{
cpuColumn,
nextPidColumn,
nextTidColumn,
TableConfiguration.PivotColumn,
nextCommandColumn,
previousStateColumn,
nextThreadPreviousSwitchOutTimeColumn,
previousTidColumn,
readyingPidColumn,
readyingTidColumn,
readyTimeColumn,
waitTimeColumn,
switchedInTimeColumn,
priorityColumn,
TableConfiguration.GraphColumn,
switchInTimeColumn,
switchOutTimeColumn
},
Layout = TableLayoutStyle.GraphAndTable,
InitialFilterShouldKeep = false,
InitialFilterQuery = filterIdleSamplesQuery,
};
timelineByCPUTableConfig.AddColumnRole(ColumnRole.EndThreadId, nextTidColumn);
timelineByCPUTableConfig.AddColumnRole(ColumnRole.StartTime, switchInTimeColumn);
timelineByCPUTableConfig.AddColumnRole(ColumnRole.ResourceId, cpuColumn);
timelineByCPUTableConfig.AddColumnRole(ColumnRole.WaitEndTime, switchInTimeColumn);
timelineByCPUTableConfig.AddColumnRole(ColumnRole.Duration, switchedInTimeColumn);
var utilByProcessCmdTable = new TableConfiguration("Utilization by Process Id, Thread Id, Cmd")
{
Columns = new[]
{
nextPidColumn,
nextTidColumn,
nextCommandColumn,
TableConfiguration.PivotColumn,
cpuColumn,
previousStateColumn,
nextThreadPreviousSwitchOutTimeColumn,
previousTidColumn,
readyingPidColumn,
readyingTidColumn,
switchInTimeColumn,
readyTimeColumn,
waitTimeColumn,
switchedInTimeColumn,
priorityColumn,
TableConfiguration.GraphColumn,
percentCpuUsagePreset,
},
Layout = TableLayoutStyle.GraphAndTable,
InitialFilterShouldKeep = false,
InitialFilterQuery = filterIdleSamplesQuery,
};
utilByProcessCmdTable.AddColumnRole(ColumnRole.EndThreadId, nextTidColumn);
utilByProcessCmdTable.AddColumnRole(ColumnRole.StartTime, switchInTimeColumn);
utilByProcessCmdTable.AddColumnRole(ColumnRole.ResourceId, cpuColumn);
utilByProcessCmdTable.AddColumnRole(ColumnRole.WaitEndTime, switchInTimeColumn);
utilByProcessCmdTable.AddColumnRole(ColumnRole.Duration, switchedInTimeColumn);
var utilByCpuTable = new TableConfiguration("Utilization by CPU")
{
Columns = new[]
{
cpuColumn,
TableConfiguration.PivotColumn,
nextPidColumn,
nextTidColumn,
nextCommandColumn,
previousStateColumn,
nextThreadPreviousSwitchOutTimeColumn,
previousTidColumn,
readyingPidColumn,
readyingTidColumn,
switchInTimeColumn,
readyTimeColumn,
waitTimeColumn,
switchedInTimeColumn,
priorityColumn,
TableConfiguration.GraphColumn,
percentCpuUsagePreset,
},
Layout = TableLayoutStyle.GraphAndTable,
InitialFilterShouldKeep = false,
InitialFilterQuery = filterIdleSamplesQuery,
};
utilByCpuTable.AddColumnRole(ColumnRole.EndThreadId, nextTidColumn);
utilByCpuTable.AddColumnRole(ColumnRole.StartTime, switchInTimeColumn);
utilByCpuTable.AddColumnRole(ColumnRole.ResourceId, cpuColumn);
utilByCpuTable.AddColumnRole(ColumnRole.WaitEndTime, switchInTimeColumn);
utilByCpuTable.AddColumnRole(ColumnRole.Duration, switchedInTimeColumn);
var table = tableBuilder.AddTableConfiguration(timelineByCPUTableConfig)
.AddTableConfiguration(utilByProcessCmdTable)
.AddTableConfiguration(utilByCpuTable)
.SetDefaultTableConfiguration(utilByProcessCmdTable)
.SetRowCount(threads.Count);
var switchInTime = Projection.CreateUsingFuncAdaptor((i) => threads[i].SwitchInTime);
var switchOutTime = Projection.CreateUsingFuncAdaptor((i) => threads[i].SwitchOutTime);
table.AddColumn(cpuColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].Cpu));
table.AddColumn(nextPidColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].NextPid));
table.AddColumn(nextTidColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].NextTid));
table.AddColumn(previousStateColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].PreviousState));
table.AddColumn(nextThreadPreviousSwitchOutTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].NextThreadPreviousSwitchOutTime));
table.AddColumn(previousTidColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].PreviousTid));
table.AddColumn(readyingPidColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ReadyingPid));
table.AddColumn(readyingTidColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ReadyingTid));
table.AddColumn(readyTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ReadyTime));
table.AddColumn(waitTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].WaitTime));
table.AddColumn(switchedInTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].SwitchOutTime - threads[i].SwitchInTime));
table.AddColumn(priorityColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].Priority));
table.AddColumn(switchInTimeColumn, switchInTime);
table.AddColumn(switchOutTimeColumn, switchOutTime);
table.AddColumn(previousPidColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].PreviousPid));
table.AddColumn(nextCommandColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].NextImage));
table.AddColumn(previousCommandColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].PreviousImage));
// Time the thread switching in switches out
var viewportClippedSwitchOutTimeForNextOnCpuColumn = Projection.ClipTimeToViewport.Create(switchOutTime);
// Switch in time is the thread switching in, which is the switch out time of the thread switching out on the CPU
var viewportClippedSwitchOutTimeForPreviousOnCpuColumn = Projection.ClipTimeToViewport.Create(switchInTime);
IProjection <int, TimestampDelta> cpuUsageInViewportColumn = Projection.Select(
viewportClippedSwitchOutTimeForNextOnCpuColumn,
viewportClippedSwitchOutTimeForPreviousOnCpuColumn,
new ReduceTimeSinceLastDiff());
var percentCpuUsageColumn = Projection.ViewportRelativePercent.Create(cpuUsageInViewportColumn);
var cpuUsageColumn = Projection.Select(switchOutTime, switchInTime, new ReduceTimeSinceLastDiff());
table.AddColumn(cpuUsageInViewportPreset, cpuUsageInViewportColumn);
table.AddColumn(cpuUsagePreset, cpuUsageColumn);
table.AddColumn(percentCpuUsagePreset, percentCpuUsageColumn);
}