public void Run(AnalysisSession analysisSession, string[] arguments) { foreach (var runtimeThread in analysisSession.Context.Runtime.Threads) { analysisSession.Reporter.Write(new ThreadStacks(runtimeThread)); } }
protected override async Task RunAsyncCore(IConsole console, string[] args, AnalysisSession session, TraceLog trace) { if (args.Length < 1) { console.Error.WriteLine("Usage: eventstack <eventIndex>"); return; } if (!int.TryParse(args[0], NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var eventIndex)) { console.Error.WriteLine("Usage: eventstack <eventIndex>"); return; } var evt = trace.Events.ElementAt(eventIndex); var stack = evt.CallStack(); if (stack != null) { WriteStack(stack, console); } else { console.Error.WriteLine($"Unable to find any call stacks for event {eventIndex:X4}!"); } }
protected async Task SaveChanges(AnalysisSession analysisSession, CancellationToken cancellationToken) { await DbContext.SaveChangesAsync(cancellationToken); analysisSession.DeletedDocumentsCount = await DbContext.DocumentRepository .Where(d => d.Folder.NavigationProviderId == Id && d.LatestAnalysisSessionId != analysisSession.Id) .CountAsync(cancellationToken); await DbContext.VerseRelationRepository.DeleteAsync( v => v.DocumentParagraph.Document.Folder.NavigationProviderId == Id && v.DocumentParagraph.Document.LatestAnalysisSessionId != analysisSession.Id, cancellationToken); await DbContext.VerseEntryRepository.DeleteAsync( v => v.DocumentParagraph.Document.Folder.NavigationProviderId == Id && v.DocumentParagraph.Document.LatestAnalysisSessionId != analysisSession.Id, cancellationToken); await DbContext.DocumentParagraphRepository.DeleteAsync( p => p.Document.Folder.NavigationProviderId == Id && p.Document.LatestAnalysisSessionId != analysisSession.Id, cancellationToken); await DbContext.DocumentRepository.DeleteAsync( d => d.Folder.NavigationProviderId == Id && d.LatestAnalysisSessionId != analysisSession.Id, cancellationToken); await DbContext.DocumentFolderRepository.DeleteAsync( f => f.NavigationProviderId == Id && f.LatestAnalysisSessionId != analysisSession.Id, cancellationToken); }
protected override Task RunAsyncCore(IConsole console, string[] args, AnalysisSession session, TraceLog trace) { var prefix = string.Empty; if (args.Length > 0) { prefix = args[0]; } console.WriteLine("Scanning log events..."); var events = trace.Events .Where(t => string.Equals(t.ProviderName, "Microsoft-Extensions-Logging") && string.Equals(t.EventName, "MessageJson") && ((string)t.PayloadByName("LoggerName")).StartsWith(prefix)) .Select(e => e.Clone()) .ToList(); console.WriteLine("Logs:"); foreach (var evt in events) { var log = LogMessage.Load(evt); console.WriteLine($"* ({((int)evt.EventIndex).ToString("X4")}) [{log.Timestamp:O}] [{log.Level}] {log.LoggerName}({log.EventId}): {log.Message}"); foreach (var(key, value) in log.Arguments) { console.WriteLine($" {key} = {value}"); } } return(Task.CompletedTask); }
private List <DocumentFolder> GetDocumentFolders(AnalysisSession analysisSession, IEnumerable <string> folderPaths, DocumentFolder parentFolder) { var result = new List <DocumentFolder>(); foreach (var folder in folderPaths) { var documentFolder = DbContext.DocumentFolderRepository.SingleOrDefault(f => f.Path == folder); if (documentFolder == null) { documentFolder = new DocumentFolder() { Name = Path.GetFileName(folder), ParentFolder = parentFolder, Path = folder, NavigationProviderId = Id }; DbContext.DocumentFolderRepository.Add(documentFolder); } documentFolder.LatestAnalysisSession = analysisSession; result.Add(documentFolder); } return(result); }
public void Build([DisallowNull] AnalysisSession session, [DisallowNull] ObservableCollection <GraphMethodRoot> methodRoots) { if (session == null) { throw new ArgumentNullException(nameof(session)); } if (methodRoots == null) { throw new ArgumentNullException(nameof(methodRoots)); } foreach (var value in session.Files) { if (!value.LoadParsedSource()) { Log.Error("Failed to load & parse {File}", value.SourceFile); continue; } foreach (var parsedClass in value.ParsedClasses) { BuildGraphForClass(parsedClass, methodRoots); } } }
private Dictionary <DocumentFolder, ContainerInfo> GetDocumentFolders( AnalysisSession analysisSession, IEnumerable <ContainerInfo> containerInfos, DocumentFolder parentFolder) { var result = new Dictionary <DocumentFolder, ContainerInfo>(); foreach (var container in containerInfos) { var documentFolder = DbContext.DocumentFolderRepository.SingleOrDefault(f => f.Path == container.Id); if (documentFolder == null) { documentFolder = new DocumentFolder() { Name = container.Name, ParentFolder = parentFolder, Path = container.Id, NavigationProviderId = Id }; DbContext.DocumentFolderRepository.Add(documentFolder); } documentFolder.LatestAnalysisSession = analysisSession; result.Add(documentFolder, container); } return(result); }
public override Task <IEnumerable <WebDocumentId> > LoadDocuments( AnalysisSession analysisSession, bool newOnly, bool updateDb = true, CancellationToken cancellationToken = default) { throw new NotImplementedException(); // todo }
public async Task RunAsync(IConsole console, string[] args, AnalysisSession session) { foreach (var thread in session.Runtime.Threads) { var isActive = session.ActiveThreadId == thread.ManagedThreadId ? "." : " "; await console.Out.WriteLineAsync($"{isActive}{thread.ManagedThreadId.ToString().PadLeft(2)} Id: {Utils.FormatAddress(thread.OSThreadId)} Teb: {Utils.FormatAddress(thread.Teb)}"); } }
public async Task RunAsync(IConsole console, string[] args, AnalysisSession session) { foreach (var frame in session.ActiveThread.EnumerateStackTrace()) { var methodInfo = frame.Method == null ? "<Unknown Method>" : GenerateMethodInfo(frame.Method); await console.Out.WriteLineAsync($"{frame.StackPointer:x16} {frame.InstructionPointer:x16} {methodInfo}"); } }
public IActionResult Index(string command, string arguments) { var analyzer = _analyzerFactory.CreateAnalyzer(command); var reporter = new AggregateReporter(); var session = new AnalysisSession(_context, reporter); analyzer.Run(session, (arguments ?? string.Empty).Split(" ")); return(View("Result", new Result(command + " " + arguments, reporter.Results))); }
public IActionResult Index(string name) { var analyzer = _analyzerFactory.CreateAnalyzer(name); var reporter = new AggregateReporter(); var session = new AnalysisSession(_context, reporter); analyzer.Run(session); return(View("Result", reporter.Results)); }
private IEnumerable <Document> GetFolderDocuments(AnalysisSession analysisSession, IEnumerable <string> folderPaths, DocumentFolder parentFolder, bool newOnly) { if (newOnly) { throw new NotSupportedException($"{nameof(newOnly)} is for WebNavigationProvider only"); } var result = new List <Document>(); var documentFolders = GetDocumentFolders(analysisSession, folderPaths, parentFolder); foreach (var dFolder in documentFolders) { var files = Directory .GetFiles(dFolder.Path, "*", SearchOption.TopDirectoryOnly) .Where(f => FileTypeHelper.SupportedFileExtensions.Contains(Path.GetExtension(f))); foreach (var filePath in files) { var lastModifiedTime = File.GetLastWriteTime(filePath); var document = DbContext.DocumentRepository.SingleOrDefault(d => d.Path == filePath); if (document == null) { document = new Document() { Folder = dFolder, Name = Path.GetFileName(filePath), Path = filePath, LastModifiedTime = lastModifiedTime }; DbContext.DocumentRepository.Add(document); analysisSession.CreatedDocumentsCount++; } else { if (document.LastModifiedTime != lastModifiedTime) { document.LastModifiedTime = lastModifiedTime; analysisSession.UpdatedDocumentsCount++; } } document.LatestAnalysisSession = analysisSession; if (!newOnly || document.Id <= 0) // По непонятным причинам EF Core для нового файла выставляет Id = -2147482647 { result.Add(document); } } var subFolderPaths = Directory.GetDirectories(dFolder.Path, "*", SearchOption.TopDirectoryOnly); result.AddRange(GetFolderDocuments(analysisSession, subFolderPaths, dFolder, newOnly)); } return(result); }
public async Task RunAsync(IConsole console, string[] args, AnalysisSession session) { if (session.Dump == null) { await console.Error.WriteLineAsync("This command requires a memory dump!"); } else { await RunAsyncCoreAsync(console, args, session, session.Dump); } }
private MNCDContext InitCtx(string dbName) { var options = new DbContextOptionsBuilder <MNCDContext>() .UseInMemoryDatabase(databaseName: dbName) .Options; var ctx = new MNCDContext(options); var datasets = new List <NetworkDataSet> { DataSetHelper.Florentine, DataSetHelper.LouvainTest, }; ctx.DataSets.AddRange(datasets); ctx.SaveChanges(); var requests = new List <AnalysisRequest> { new AnalysisRequest { CreateDate = new DateTime(2020, 12, 01), DataSet = DataSetHelper.Florentine, SelectedLayer = 0, Approach = AnalysisApproach.SingleLayerFlattening, AnalysisAlgorithm = AnalysisAlgorithm.Louvain, AnalysisAlgorithmParameters = new Dictionary <string, string>(), FlatteningAlgorithm = FlatteningAlgorithm.BasicFlattening, FlatteningAlgorithmParameters = new Dictionary <string, string>(), } }; var analyses = new List <Analysis> { new Analysis { Request = requests[0] } }; ctx.Analyses.AddRange(analyses); ctx.SaveChanges(); var session = new AnalysisSession { Name = "AnalysisSession", Analyses = analyses, }; ctx.AnalysisSessions.Add(session); ctx.SaveChanges(); return(new MNCDContext(options)); }
public async Task RunAsync(IConsole console, string[] args, AnalysisSession session) { if (session.Trace == null) { await console.Error.WriteLineAsync("This command requires an event trace!"); } else { await RunAsyncCore(console, args, session, session.Trace); } }
private IEnumerable <Document> GetHierarchyDocuments( AnalysisSession analysisSession, IEnumerable <ContainerInfo> containerInfos, DocumentFolder parentFolder, bool newOnly) { if (newOnly) { throw new NotSupportedException($"{nameof(newOnly)} is for WebNavigationProvider only"); } var result = new List <Document>(); var documentFolders = GetDocumentFolders(analysisSession, containerInfos, parentFolder); foreach (var dFolderKVP in documentFolders) { foreach (var pageInfo in dFolderKVP.Value.Pages) { var document = DbContext.DocumentRepository.SingleOrDefault(d => d.Path == pageInfo.Id); if (document == null) { document = new Document() { Folder = dFolderKVP.Key, Name = pageInfo.Name, Path = pageInfo.Id, LastModifiedTime = pageInfo.LastModifiedTime, }; DbContext.DocumentRepository.Add(document); analysisSession.CreatedDocumentsCount++; } else { if (document.LastModifiedTime != pageInfo.LastModifiedTime) { document.LastModifiedTime = pageInfo.LastModifiedTime; analysisSession.UpdatedDocumentsCount++; } } document.LatestAnalysisSession = analysisSession; if (!newOnly || document.Id <= 0) // По непонятным причинам EF Core для нового файла выставляет Id = -2147482647 { result.Add(document); } } result.AddRange(GetHierarchyDocuments(analysisSession, dFolderKVP.Value.ChildrenContainers, dFolderKVP.Key, newOnly)); } return(result); }
protected override Task RunAsyncCoreAsync(IConsole console, string[] args, AnalysisSession session, MemoryDump dump) { var stats = dump.ComputeHeapStatistics().OrderBy(s => s.TotalSize); console.WriteLine(" MT Count TotalSize Class Name"); foreach (var heapStats in stats) { console.WriteLine($"{heapStats.Type.MethodTable:X16} {heapStats.Count.ToString().PadLeft(8)} {heapStats.TotalSize.ToString().PadLeft(12)} {heapStats.Type.Name}"); } return(Task.CompletedTask); }
protected override Task RunAsyncCore(IConsole console, string[] args, AnalysisSession session, TraceLog trace) { console.WriteLine("Scanning request events..."); var requests = trace.Events .Where(t => string.Equals(t.ProviderName, "Microsoft-AspNetCore-Hosting") && string.Equals(t.EventName, "RequestStart/Start")) .Select(e => e.Clone()) .ToList(); console.WriteLine("HTTP requests:"); foreach (var request in requests) { console.WriteLine($"* ({((int)request.EventIndex).ToString("X4")}) [{request.TimeStamp:O}] {request.PayloadString(0)} {request.PayloadString(1)}"); } return(Task.CompletedTask); }
static void Main(string[] args) { Log.Logger = new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.Console() .CreateLogger(); var analysisSession = new AnalysisSession(); foreach (var s in args) { var file = new FileInfo(s); if (!file.Exists) { continue; } if (file.Extension != ".cs") { continue; } analysisSession.Add(file); } if (analysisSession.Files.Count == 0) { return; } var stopwatch = new Stopwatch(); stopwatch.Start(); analysisSession.BuildGraph(); stopwatch.Stop(); Log.Information("DFG: {Time}", stopwatch.Elapsed); foreach (var methodRoot in analysisSession.CurrentMethodRoots) { Print(methodRoot); } }
public async Task <AnalysisSession> AddAnalysisSession(string name) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("Name cannot be empty.", nameof(name)); } var session = new AnalysisSession { Name = name, CreateDate = DateTime.Now }; await _ctx.AnalysisSessions.AddAsync(session); await _ctx.SaveChangesAsync(); return(session); }
public void Run(AnalysisSession analysisSession, string[] arguments) { var groups = analysisSession.Context.Runtime.Heap.EnumerateObjects().GroupBy(o => o.Type.Name).ToList(); var heapStats = new HeapStatistics() { TotalUniqueObjects = groups.Count, Types = groups.Select(g => { var objs = g.ToList(); return(new HeapTypeStatistics() { TypeName = new TypeRef(g.Key), Count = objs.Count, TotalSize = objs.Aggregate(0ul, (l, o) => l + o.Size) }); }).OrderByDescending(t => t.TotalSize) }; analysisSession.Reporter.Write(heapStats); }
public override async Task <IEnumerable <FileDocumentId> > LoadDocuments( AnalysisSession analysisSession, bool newOnly, bool updateDb = true, CancellationToken cancellationToken = default) { var documents = new List <Document>(); foreach (var folder in Parameters.FolderPaths) { var folderDocuments = GetFolderDocuments(analysisSession, new[] { folder }, null, newOnly); documents.AddRange(folderDocuments); } if (updateDb) { await SaveChanges(analysisSession, cancellationToken); } return(documents.Select(d => new FileDocumentId(d.Id, d.Path, IsReadonly))); }
public async Task <AnalysisSession> GetActualSession(int navigationProviderId, CancellationToken cancellationToken = default) { var analysisSession = await this.dbContext.AnalysisSessions .Where(s => s.NavigationProviderId == navigationProviderId) .Where(s => s.Status == AnalysisSessionStatus.NotStarted) .OrderByDescending(s => s.GetDocumentsInfoTime) .FirstOrDefaultAsync(cancellationToken); if (analysisSession == null) { analysisSession = new AnalysisSession() { NavigationProviderId = navigationProviderId, Status = AnalysisSessionStatus.NotStarted }; this.dbContext.AnalysisSessions.Add(analysisSession); await dbContext.SaveChangesAsync(cancellationToken); } return(analysisSession); }
public override async Task <IEnumerable <OneNoteDocumentId> > LoadDocuments( AnalysisSession analysisSession, bool newOnly = false, bool updateDb = true, CancellationToken cancellationToken = default) { var documents = new List <Document>(); foreach (var item in Parameters.HierarchyItems) { var hierarchyInfo = await this.notebookIterator.GetHierarchyPagesAsync(item.Id, item.Type); var hierarchyDocuments = GetHierarchyDocuments(analysisSession, new[] { hierarchyInfo }, null, newOnly); documents.AddRange(hierarchyDocuments); } await DbContext.DoInTransactionAsync(async (cancellationToken) => { await SaveChanges(analysisSession, cancellationToken); return(updateDb); }, cancellationToken); return(documents.Select(d => new OneNoteDocumentId(d.Id, d.Path))); }
public void Run(AnalysisSession analysisSession) { var pool = analysisSession.Context.Runtime.ThreadPool; analysisSession.Reporter.Write(new Table("ThreadPool status", new[] { new [] { nameof(pool.TotalThreads), pool.TotalThreads.ToString() }, new [] { nameof(pool.RunningThreads), pool.RunningThreads.ToString() }, new [] { nameof(pool.IdleThreads), pool.IdleThreads.ToString() }, new [] { nameof(pool.CpuUtilization), pool.CpuUtilization.ToString() }, new [] { nameof(pool.FreeCompletionPortCount), pool.FreeCompletionPortCount.ToString() } })); analysisSession.Reporter.Write(new Table("ThreadPool limits", new[] { new [] { nameof(pool.MinThreads), pool.MinThreads.ToString() }, new [] { nameof(pool.MaxThreads), pool.MaxThreads.ToString() }, new [] { nameof(pool.MinCompletionPorts), pool.MinCompletionPorts.ToString() }, new [] { nameof(pool.MaxCompletionPorts), pool.MaxCompletionPorts.ToString() }, new [] { nameof(pool.MaxFreeCompletionPorts), pool.MaxFreeCompletionPorts.ToString() }, })); }
public Task RunAsync(IConsole console, string[] args, AnalysisSession session) { if (session.Dump != null) { console.WriteLine("Memory Dump:"); console.WriteLine($" CLR Version: {session.Dump.Runtime.ClrInfo.Version}"); console.WriteLine($" CLR Flavor: {session.Dump.Runtime.ClrInfo.Flavor}"); } else { console.WriteLine("No Memory Dump Loaded."); } if (session.Trace != null) { console.WriteLine("Trace:"); console.WriteLine($" OS: {session.Trace.OSName} {session.Trace.OSVersion}"); } else { console.WriteLine("No Trace Loaded."); } return(Task.CompletedTask); }
protected abstract Task RunAsyncCore(IConsole console, string[] args, AnalysisSession session, TraceLog trace);
public abstract Task <IEnumerable <T> > LoadDocuments( AnalysisSession analysisSession, bool newOnly = false, bool updateDb = true, CancellationToken cancellationToken = default);
protected abstract Task RunAsyncCoreAsync(IConsole console, string[] args, AnalysisSession session, MemoryDump dump);