示例#1
0
        private Dictionary <string, RuleMetrics> CreateRuleMetricsMap(SarifLog sarifLog)
        {
            var ruleIdToRuleMetricsMap = new Dictionary <string, RuleMetrics>();

            foreach (Run run in sarifLog.Runs)
            {
                if (run.Results == null)
                {
                    continue;
                }

                string toolName = run.Tool.Driver.Name;

                foreach (Result result in run.Results)
                {
                    // In our current design, input log files contain only candidate results
                    // to file. A transformer, however, might suppress a result as part of its
                    // operation.
                    Debug.Assert(result.ShouldBeFiled() || result.Suppressions?.Count > 0);

                    string ruleId = result.GetRule(run).Id;
                    string key    = toolName + ruleId;

                    if (!ruleIdToRuleMetricsMap.TryGetValue(key, out RuleMetrics ruleMetrics))
                    {
                        ruleIdToRuleMetricsMap[key] = ruleMetrics =
                            new RuleMetrics
                        {
                            Tool   = toolName,
                            RuleId = ruleId
                        };
                    }

                    if (result.Kind == ResultKind.Open)
                    {
                        ruleMetrics.OpenCount++;
                        continue;
                    }

                    if (result.Kind == ResultKind.Review)
                    {
                        ruleMetrics.ReviewCount++;
                        continue;
                    }

                    if (result.Suppressions?.Count > 0)
                    {
                        ruleMetrics.SuppressedByTransformerCount++;
                        continue;
                    }

                    switch (result.Level)
                    {
                    case FailureLevel.Error:
                    {
                        ruleMetrics.ErrorCount++;
                        break;
                    }

                    case FailureLevel.Warning:
                    {
                        ruleMetrics.WarningCount++;
                        break;
                    }

                    case FailureLevel.Note:
                    {
                        ruleMetrics.NoteCount++;
                        break;
                    }

                    case FailureLevel.None:
                    {
                        throw new InvalidOperationException();
                    }
                    }
                }
            }
            return(ruleIdToRuleMetricsMap);
        }
示例#2
0
        private void LogMetricsForProcessedModel(SarifLog sarifLog, SarifWorkItemModel sarifWorkItemModel, FilingResult filingResult, Dictionary <string, object> additionalCustomDimensions = null)
        {
            additionalCustomDimensions ??= new Dictionary <string, object>();

            this.FilingResult = filingResult;

            string logGuid = sarifLog.GetProperty <Guid>("guid").ToString();
            string tags    = string.Join(",", sarifWorkItemModel.LabelsOrTags);
            string uris    = sarifWorkItemModel.LocationUris?.Count > 0
                ? string.Join(",", sarifWorkItemModel.LocationUris)
                : "";

            var workItemMetrics = new Dictionary <string, object>
            {
                { "LogGuid", logGuid },
                { "WorkItemModelGuid", sarifWorkItemModel.Guid },
                { nameof(sarifWorkItemModel.Area), sarifWorkItemModel.Area },
                { nameof(sarifWorkItemModel.BodyOrDescription), sarifWorkItemModel.BodyOrDescription },
                { "FilingResult", filingResult.ToString() },
                { nameof(sarifWorkItemModel.CommentOrDiscussion), sarifWorkItemModel.CommentOrDiscussion },
                { nameof(sarifWorkItemModel.HtmlUri), sarifWorkItemModel.HtmlUri },
                { nameof(sarifWorkItemModel.Iteration), sarifWorkItemModel.Iteration },
                { "LabelsOrTags", tags },
                { "LocationUri", uris },
                { nameof(sarifWorkItemModel.Milestone), sarifWorkItemModel.Milestone },
                { nameof(sarifWorkItemModel.OwnerOrAccount), sarifWorkItemModel.OwnerOrAccount },
                { nameof(sarifWorkItemModel.RepositoryOrProject), sarifWorkItemModel.RepositoryOrProject },
                { nameof(sarifWorkItemModel.Title), sarifWorkItemModel.Title },
                { nameof(sarifWorkItemModel.Uri), sarifWorkItemModel.Uri },
            };

            foreach (string key in additionalCustomDimensions.Keys)
            {
                workItemMetrics.Add(key, additionalCustomDimensions[key]);
            }

            EventId coreEventId;

            switch (filingResult)
            {
            case FilingResult.Canceled:
                coreEventId = EventIds.WorkItemCanceledCoreMetrics;
                break;

            case FilingResult.ExceptionRaised:
                coreEventId = EventIds.WorkItemExceptionCoreMetrics;
                break;

            default:
                coreEventId = EventIds.WorkItemFiledCoreMetrics;
                break;
            }

            this.Logger.LogMetrics(coreEventId, workItemMetrics);

            Dictionary <string, RuleMetrics> ruleIdToMetricsMap = CreateRuleMetricsMap(sarifLog);

            foreach (string tool in ruleIdToMetricsMap.Keys)
            {
                RuleMetrics ruleMetrics = ruleIdToMetricsMap[tool];

                var workItemDetailMetrics = new Dictionary <string, object>
                {
                    { "LogGuid", logGuid },
                    { "WorkItemModelGuid", sarifWorkItemModel.Guid },
                    { nameof(ruleMetrics.Tool), ruleMetrics.Tool },
                    { nameof(ruleMetrics.RuleId), ruleMetrics.RuleId },
                    { nameof(ruleMetrics.ErrorCount), ruleMetrics.ErrorCount },
                    { nameof(ruleMetrics.WarningCount), ruleMetrics.WarningCount },
                    { nameof(ruleMetrics.NoteCount), ruleMetrics.NoteCount },
                    { nameof(ruleMetrics.OpenCount), ruleMetrics.OpenCount },
                    { nameof(ruleMetrics.ReviewCount), ruleMetrics.ReviewCount },
                    { nameof(ruleMetrics.SuppressedByTransformerCount), ruleMetrics.SuppressedByTransformerCount }
                };

                this.Logger.LogMetrics(EventIds.WorkItemFiledDetailMetrics, workItemDetailMetrics);
            }
        }