public static ElasticSDResult FromResult(SDResult result, BundleMetainfo bundleInfo, DumpMetainfo dumpInfo)
{
ElasticSDResult eResult = new ElasticSDResult()
{
BundleId = dumpInfo.BundleId,
DumpId = dumpInfo.DumpId,
Timestamp = dumpInfo.Created,
Type = dumpInfo.DumpType.ToString(),
Executable = (result.SystemContext as SDCDSystemContext)?.FileName ?? "",
IsManaged = result.IsManagedProcess,
ProcessArchitecture = result.SystemContext.ProcessArchitecture,
SystemArchitecture = result.SystemContext.SystemArchitecture,
NrThreads = result.ThreadInformation.Count,
LastEventDescription = result.LastEvent?.Description,
LoadedModules = result.SystemContext.DistinctModules().Select(m => m.FileName).Aggregate("", (m1, m2) => m1 + " " + m2),
LoadedModulesVersioned = result.SystemContext.DistinctModules().Select(m => $"{m.FileName}:{m.Version ?? "-"}").Aggregate("", (m1, m2) => m1 + " " + m2),
DynatraceLoadedModulesVersioned = result.SystemContext.DistinctModules().Where(m => m.Tags.Contains(SDTag.DynatraceAgentTag)).Select(m => $"{m.FileName}:{m.Version ?? "-"}").Aggregate("", (m1, m2) => m1 + " " + m2),
ExitType = result.LastEvent?.Type ?? ""
};
bundleInfo.CustomProperties.TryGetValue("ref", out string reference);
eResult.Reference = reference;
if (dumpInfo.Finished != null && dumpInfo.Started != null)
{
int durationSecs = (int)dumpInfo.Finished.Subtract(dumpInfo.Started).TotalSeconds;
if (durationSecs > 0)
{
// Only if a valid duration is present
eResult.AnalyzationDuration = durationSecs;
}
}
return(eResult);
}
private async Task SearchBundleAsync(BundleMetainfo bundle, bool force)
{
IList <JiraIssueModel> jiraIssues;
if (!force && bundle.CustomProperties.TryGetValue(settings.CustomPropertyJiraIssueKey, out string jiraIssue))
{
jiraIssues = new List <JiraIssueModel>()
{
new JiraIssueModel {
Key = jiraIssue
}
};
}
else
{
jiraIssues = (await apiService.GetJiraIssues(bundle.BundleId)).ToList();
}
if (jiraIssues.Any())
{
bundleIssues[bundle.BundleId] = jiraIssues;
await jiraIssueStorage.Store(bundle.BundleId, jiraIssues);
}
else
{
bundleIssues.Remove(bundle.BundleId, out var val);
await jiraIssueStorage.Store(bundle.BundleId, Enumerable.Empty <JiraIssueModel>());
}
}
public BundleMetainfo Create(string filename, DumpAnalysisInput input)
{
lock (sync) {
string bundleId = CreateUniqueBundleId();
var bundleInfo = new BundleMetainfo()
{
BundleId = bundleId,
BundleFileName = filename,
Created = DateTime.Now,
Status = BundleStatus.Created
};
bundleInfo.CustomProperties = input.CustomProperties;
if (!string.IsNullOrEmpty(input.JiraIssue))
{
bundleInfo.CustomProperties["ref"] = input.JiraIssue;
}
if (!string.IsNullOrEmpty(input.FriendlyName))
{
bundleInfo.CustomProperties["note"] = input.FriendlyName;
}
bundles[bundleId] = bundleInfo;
storage.Store(bundleInfo);
return(bundleInfo);
}
}
private static long ComputeDumpFileSizeKb(BundleMetainfo bundleInfo, DumpMetainfo dumpInfo, PathHelper pathHelper)
{
long dumpSize = -1;
string dumpDirectory = pathHelper.GetDumpDirectory(bundleInfo.BundleId, dumpInfo.DumpId);
if (!Directory.Exists(dumpDirectory))
{
return(-1);
}
foreach (var file in Directory.EnumerateFiles(dumpDirectory))
{
if (file.EndsWith(".core.gz") || file.EndsWith(".dmp"))
{
FileInfo fi = new FileInfo(file);
dumpSize = fi.Length;
break;
}
}
if (dumpSize == -1)
{
// No dump found
return(-1);
}
return(dumpSize / 1024);
}
public static ElasticSDResult FromResultOrDefault(SDResult result, BundleMetainfo bundleInfo, DumpMetainfo dumpInfo, PathHelper pathHelper)
{
try {
return(FromResult(result, bundleInfo, dumpInfo, pathHelper));
} catch (Exception e) {
Console.Error.WriteLine($"ElasticSDResult.FromResult failed for {dumpInfo.Id}: {e.ToString()}");
}
return(null);
}
public BundleViewModel(BundleMetainfo bundleInfo, IEnumerable <DumpMetainfo> dumpInfos)
{
this.BundleId = bundleInfo.BundleId;
this.Created = bundleInfo.Created;
this.Status = bundleInfo.Status;
this.CustomProperties = bundleInfo.CustomProperties;
this.DumpInfos = dumpInfos ?? new List <DumpMetainfo>();
this.ErrorMessage = bundleInfo.ErrorMessage;
}
public IActionResult TriggerSimilarityAnalysis(string bundleId, string dumpId)
{
BundleMetainfo bundleInfo = bundleRepository.Get(bundleId);
if (bundleInfo == null)
{
logger.LogNotFound("TriggerSimilarityAnalysis: Bundle not found", HttpContext, "BundleId", bundleId);
return(View(null));
}
logger.LogDumpAccess("TriggerSimilarityAnalysis", HttpContext, bundleInfo, dumpId); //TODO check if bundle exists
similarityService.ScheduleSimilarityAnalysis(new DumpIdentifier(bundleId, dumpId), true, DateTime.MinValue);
return(RedirectToAction("Report", "Home", new { bundleId = bundleId, dumpId = dumpId })); // View("/Home/Report", new ReportViewModel(bundleId, dumpId));
}
public async Task <bool> PushResultAsync(SDResult result, BundleMetainfo bundleInfo, DumpMetainfo dumpInfo)
{
if (elasticClient != null)
{
var response = await elasticClient.CreateAsync(ElasticSDResult.FromResult(result, bundleInfo, dumpInfo, pathHelper));
if (!response.Created)
{
return(false);
}
}
return(true);
}
public static ElasticSDResult FromResult(SDResult result, BundleMetainfo bundleInfo, DumpMetainfo dumpInfo, PathHelper pathHelper)
{
if (result == null)
{
throw new ArgumentNullException("result");
}
var eResult = new ElasticSDResult()
{
BundleId = dumpInfo.BundleId,
DumpId = dumpInfo.DumpId,
Timestamp = dumpInfo.Created,
Type = dumpInfo.DumpType.ToString(),
Executable = (result.SystemContext as SDCDSystemContext)?.FileName ?? "",
IsManaged = result.IsManagedProcess,
ProcessArchitecture = result.SystemContext?.ProcessArchitecture,
SystemArchitecture = result.SystemContext?.SystemArchitecture,
NrThreads = result.ThreadInformation != null ? result.ThreadInformation.Count : 0,
LastEventDescription = result.LastEvent?.Description,
LoadedModules = result.SystemContext?.DistinctModules().Select(m => m.FileName).Aggregate("", (m1, m2) => m1 + " " + m2),
LoadedModulesVersioned = result.SystemContext?.DistinctModules().Select(m => $"{m.FileName}:{m.Version ?? "-"}").Aggregate("", (m1, m2) => m1 + " " + m2),
DynatraceLoadedModulesVersioned = result.SystemContext?.DistinctModules().Where(m => m.Tags.Contains(SDTag.DynatraceAgentTag)).Select(m => $"{m.FileName}:{m.Version ?? "-"}").Aggregate("", (m1, m2) => m1 + " " + m2),
ExitType = result.LastEvent?.Type ?? ""
};
bundleInfo.CustomProperties.TryGetValue("ref", out string reference);
eResult.Reference = reference;
bundleInfo.CustomProperties.TryGetValue("tenantId", out string tenantId);
eResult.TenantId = tenantId;
eResult.FaultingStacktrace = result.GetErrorOrLastExecutingThread()?.ToText();
eResult.Stacktraces = ""; // TODO
if (dumpInfo.Finished != null && dumpInfo.Started != null)
{
int durationSecs = (int)dumpInfo.Finished.Subtract(dumpInfo.Started).TotalSeconds;
if (durationSecs > 0)
{
// Only if a valid duration is present
eResult.AnalyzationDuration = durationSecs;
}
}
long dumpSize = ComputeDumpFileSizeKb(bundleInfo, dumpInfo, pathHelper);
if (dumpSize >= 0)
{
eResult.DumpSizeKb = dumpSize;
}
return(eResult);
}
public async Task <bool> PushResultAsync(SDResult result, BundleMetainfo bundleInfo, DumpMetainfo dumpInfo)
{
if (elasticClient != null)
{
new Nest.CreateRequest <ElasticSDResult>(RESULT_IDX);
var response = await elasticClient.CreateAsync(new CreateDescriptor <ElasticSDResult>(ElasticSDResult.FromResult(result, bundleInfo, dumpInfo, pathHelper)));
if (response.Result != Result.Created)
{
return(false);
}
}
return(true);
}
public override async void AnalyzeDump(DumpMetainfo dumpInfo)
{
BundleMetainfo bundle = bundleRepo.Get(dumpInfo.BundleId);
try {
SDResult result = await dumpRepo.GetResultAndThrow(dumpInfo.Id);
if (result != null)
{
await elasticSearch.PushResultAsync(result, bundle, dumpInfo);
}
} catch (Exception ex) {
Console.WriteLine(ex.Message);
}
}
public BundleMetainfo Create(string filename, IDictionary <string, string> properties)
{
lock (sync) {
string bundleId = CreateUniqueBundleId();
var bundleInfo = new BundleMetainfo()
{
BundleId = bundleId,
BundleFileName = filename,
Created = DateTime.Now,
Status = BundleStatus.Created
};
bundleInfo.CustomProperties = properties;
bundles[bundleId] = bundleInfo;
storage.Store(bundleInfo);
return(bundleInfo);
}
}
public async Task <bool> PushResultAsync(SDResult result, BundleMetainfo bundleInfo, DumpMetainfo dumpInfo)
{
try {
if (elasticClient != null && result != null)
{
new Nest.CreateRequest <ElasticSDResult>(RESULT_IDX);
var response = await elasticClient.CreateAsync(new CreateDescriptor <ElasticSDResult>(ElasticSDResult.FromResult(result, bundleInfo, dumpInfo, pathHelper)));
if (response.Result != Result.Created)
{
return(false);
}
}
return(true);
} catch (Exception e) {
Console.WriteLine($"PushResultAsync failed for {dumpInfo.Id} with exception: {e}");
return(false);
}
}
/// <summary>
/// Older storage did not have metainfo files. We need to read full results, create new metainfo file and store it.
/// </summary>
/// <param name="bundleId"></param>
private async Task CreateBundleMetainfoForCompat(string bundleId)
{
var metainfo = new BundleMetainfo()
{
BundleId = bundleId
};
// use storage directly, not repo. repo might not be initialized yet
// back then, every dump had the same information encoded. take the first dump and use it from there.
var dumps = await dumpStorage.ReadDumpMetainfoForBundle(bundleId);
// loop through all dumps and hope to find a good one.
foreach (var dump in dumps)
{
if (dump != null)
{
metainfo.Created = dump.Created;
metainfo.Finished = dump.Created; // can't do better.
metainfo.Status = BundleStatus.Finished;
var fullresult = await dumpStorage.ReadResults(bundleId, dump.DumpId);
if (fullresult != null)
{
if (!string.IsNullOrEmpty(fullresult.AnalysisInfo.JiraIssue))
{
metainfo.CustomProperties["ref"] = fullresult.AnalysisInfo.JiraIssue;
}
if (!string.IsNullOrEmpty(fullresult.AnalysisInfo.FriendlyName))
{
metainfo.CustomProperties["note"] = fullresult.AnalysisInfo.FriendlyName;
}
break;
}
}
}
WriteMetainfoFile(metainfo, pathHelper.GetBundleMetadataPath(bundleId));
}
private static void WriteMetainfoFile(BundleMetainfo metaInfo, string filename)
{
File.WriteAllText(filename, JsonConvert.SerializeObject(metaInfo, Formatting.Indented));
}
internal void Store(BundleMetainfo bundleInfo)
{
Directory.CreateDirectory(pathHelper.GetBundleDirectory(bundleInfo.BundleId));
WriteMetainfoFile(bundleInfo, pathHelper.GetBundleMetadataPath(bundleInfo.BundleId));
}
public static void LogFileAccess(this ILogger logger, string text, HttpContext context, BundleMetainfo bundleInfo, string dumpId, string filename)
{
logger.LogInformation(FileLogText, text, context.Connection.RemoteIpAddress.ToString(), context.User.Identity.Name,
bundleInfo.BundleId, GetCustomPropertyString(bundleInfo.CustomProperties), dumpId, filename);
}
public void Store(BundleMetainfo bundleInfo)
{
throw new NotImplementedException();
}
