internal ConnectivityIssue(Origin?origin, Severity?severity, IssueType?issueType, IReadOnlyList <IDictionary <string, string> > context)
{
Origin = origin;
Severity = severity;
IssueType = issueType;
Context = context;
}
public IEnumerable <IBug> FindBugs(string description = null,
DateTime?dueBy = null,
Severity?severity = null,
IssueStatus?issueStatus = null)
{
return(_issueFilterer.FindBugs(_issues, description, dueBy, severity, issueStatus));
}
public RuleResult CheckMethod(MethodDefinition method)
{
// note: using anonymous methods creates a lot of defects but they are all non-visible
if (!method.IsVisible())
{
return(RuleResult.DoesNotApply);
}
MethodReturnType return_type = method.MethodReturnType;
Severity? severity = Check(return_type.ReturnType);
if (severity.HasValue)
{
Runner.Report(return_type, severity.Value, Confidence.Total);
}
if (method.HasParameters)
{
foreach (ParameterDefinition parameter in method.Parameters)
{
severity = Check(parameter.ParameterType);
if (severity.HasValue)
{
Runner.Report(parameter, severity.Value, Confidence.Total);
}
}
}
return(Runner.CurrentRuleResult);
}
public RuleResult CheckMethod(MethodDefinition method)
{
// rule does not apply if there's no IL code
if (!method.HasBody)
{
return(RuleResult.DoesNotApply);
}
// avoid looping if we're sure there's no call in the method
if (!OpCodeBitmask.Calls.Intersect(OpCodeEngine.GetBitmask(method)))
{
return(RuleResult.DoesNotApply);
}
foreach (Instruction instruction in method.Body.Instructions)
{
if (instruction.OpCode.FlowControl != FlowControl.Call)
{
continue;
}
Severity?severity = IsProblematicCall(instruction);
if (severity.HasValue)
{
string msg = String.Format(CultureInfo.InvariantCulture,
"You are calling to {0}, which is a potentially problematic method",
instruction.Operand);
Runner.Report(method, instruction, severity.Value, Confidence.High, msg);
}
}
return(Runner.CurrentRuleResult);
}
public void WriteMinimalDataLog(string jsonData, Severity?severity = null)
{
CreateMinimalMessageBuilder()
.Message(uShipLogging.Config.MinimalDataLogMessage)
.WithSeverity(severity)
.WithRawJsonObject(jsonData)
.Write();
}
public ValidationError(string ruleName, string learnerReferenceNumber, long?aimSequenceNumber = null, Severity?severity = null, IEnumerable <IErrorMessageParameter> errorMessageParameters = null)
{
LearnerReferenceNumber = learnerReferenceNumber;
AimSequenceNumber = aimSequenceNumber;
RuleName = ruleName;
Severity = severity;
ErrorMessageParameters = errorMessageParameters;
}
public IEnumerable <IBug> FindBugs(
IEnumerable <IIssue> issues,
string description = null,
DateTime?dueBy = null,
Severity?severity = null,
IssueStatus?issueStatus = null)
{
return(FilterBugsByDescription(GetBugs(FilterIssuesOnDueBy(FilterIssuesOnSeverity(FilterIssuesOnIssueStatus(issues, issueStatus), severity), dueBy)), description));
}
public Trace(string sourceName, string content, Severity?severity = null) : base("trace")
{
_content = content;
Attributes.Add("source", sourceName);
if (severity != null)
{
Attributes.Add("severity", severity.ToString().ToLower());
}
}
public async Task <ActionResult> Find(
DateTime?minDateTime,
DateTime?maxDateTime,
DateTime?dateTime,
string sourceService,
Severity?severity,
int pageNumber = 1,
int pageSize = 15
)
{
Expression <Func <LogMessage, bool> > mainExpression = (_) => true;
if (minDateTime != null)
{
Expression <Func <LogMessage, bool> > filterExpression = (_) => _.TimeStamp >= minDateTime;
mainExpression = filterExpression.AndAlso(mainExpression);
}
if (maxDateTime != null)
{
Expression <Func <LogMessage, bool> > filterExpression = (_) => _.TimeStamp <= maxDateTime;
mainExpression = filterExpression.AndAlso(mainExpression);
}
if (dateTime != null)
{
Expression <Func <LogMessage, bool> > filterExpression = (_) => _.TimeStamp == dateTime;
mainExpression = filterExpression.AndAlso(mainExpression);
}
if (sourceService != null)
{
Expression <Func <LogMessage, bool> > filterExpression = (_) => _.SourceService.Equals(severity);
mainExpression = filterExpression.AndAlso(mainExpression);
}
if (severity != null)
{
Expression <Func <LogMessage, bool> > filterExpression = (_) => _.Severity == severity;
mainExpression = filterExpression.AndAlso(mainExpression);
}
PagedList <LogMessage> result = _logMessageRepository.FilterBy(mainExpression, pageNumber, pageSize);
var metadata = new
{
result.TotalCount,
result.PageSize,
result.CurrentPage,
result.TotalPages,
result.HasNext,
result.HasPrevious
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(result));
}
public PythonDebuggingGeneralOptionsSetter(
DTE dte,
bool?promptBeforeRunningWithBuildErrorSetting = null,
bool?autoAnalyzeStandardLibrary = null,
Severity?indentationInconsistencySeverity = null,
bool?teeStandardOutput = null,
bool?waitOnAbnormalExit = null,
bool?waitOnNormalExit = null,
bool?useLegacyDebugger = null
)
{
_dte = dte;
var options = GetOptions();
if (promptBeforeRunningWithBuildErrorSetting.HasValue)
{
_promptBeforeRunningWithBuildErrorSetting = options.PromptBeforeRunningWithBuildErrorSetting;
options.PromptBeforeRunningWithBuildErrorSetting = promptBeforeRunningWithBuildErrorSetting.Value;
}
if (autoAnalyzeStandardLibrary.HasValue)
{
_autoAnalyzeStandardLibrary = options.AutoAnalyzeStandardLibrary;
options.AutoAnalyzeStandardLibrary = autoAnalyzeStandardLibrary.Value;
}
if (indentationInconsistencySeverity.HasValue)
{
_indentationInconsistencySeverity = options.IndentationInconsistencySeverity;
options.IndentationInconsistencySeverity = indentationInconsistencySeverity.Value;
}
if (teeStandardOutput.HasValue)
{
_teeStandardOutput = options.TeeStandardOutput;
options.TeeStandardOutput = teeStandardOutput.Value;
}
if (waitOnAbnormalExit.HasValue)
{
_waitOnAbnormalExit = options.WaitOnAbnormalExit;
options.WaitOnAbnormalExit = waitOnAbnormalExit.Value;
}
if (waitOnNormalExit.HasValue)
{
_waitOnNormalExit = options.WaitOnNormalExit;
options.WaitOnNormalExit = waitOnNormalExit.Value;
}
if (useLegacyDebugger.HasValue)
{
_useLegacyDebugger = options.UseLegacyDebugger;
options.UseLegacyDebugger = useLegacyDebugger.Value;
}
}
public void ConsumeHighlighting(
DocumentRange range,
IHighlighting error,
Severity?overriddenSeverity = null,
string overriddenHighlightingAttributeId = null,
OverlapResolveKind?overriddenOverlapResolve = null,
int?overriddenOverloadResolvePriority = null)
{
_decorated.ConsumeHighlighting(
range, error, overriddenSeverity, overriddenHighlightingAttributeId, overriddenOverlapResolve, overriddenOverloadResolvePriority);
}
public void AddFailure(string message, Severity?severity = null, IEnumerable <string> failingItems = null)
{
Failures.Add(new ScanFailure(message, failingItems));
if (!Severity.HasValue && !severity.HasValue)
{
Severity = Scan.Severity;
}
else if (severity.HasValue)
{
Severity = Severity?.ElevateSeverityIfApplicable(severity.Value) ?? severity.Value;
}
}
public static void BiThreshold <T, Y>(T left, Y right, Thresholds <T> leftThresholds, Thresholds <Y> rightThresholds, Action <Severity, T?, Y?> action, IComparer <T>?leftComparer = null, IComparer <Y>?rightComparer = null, Func <Severity?, Severity?, Severity?>?merge = null)
where T : struct
where Y : struct
{
if (merge == null)
{
merge = (s1, s2) =>
{
if (s1 == null)
{
return(s2);
}
if (s2 == null)
{
return(s1);
}
return((Severity)Math.Max((int)s1, (int)s2));
};
}
Severity?leftSeverity = null;
T? leftThreshold = null;
Threshold(left, leftThresholds, (severity, threshold) =>
{
leftSeverity = severity;
leftThreshold = threshold;
}, leftComparer);
Severity?rightSeverity = null;
Y? rightThreshold = null;
Threshold(right, rightThresholds, (severity, threshold) =>
{
rightSeverity = severity;
rightThreshold = threshold;
}, rightComparer);
var finalSeverity = merge(leftSeverity, rightSeverity);
if (finalSeverity != null)
{
action(finalSeverity.Value, leftThreshold, rightThreshold);
}
}
public string SeverityToString(Severity?severity)
{
switch (severity)
{
case Severity.Error:
return(Error);
case Severity.Warning:
return(Warning);
case null:
return(null);
default:
return(null);
}
}
public string SeverityToString(Severity?severity)
{
switch (severity)
{
case Severity.Error:
return("E");
case Severity.Warning:
return("W");
case Severity.Fail:
return("F");
case null:
return(null);
default:
return(null);
}
}
protected Answer SetAnswer(
string questionId,
Severity?severity = null,
string text = null,
Progression?progression = null)
{
if (text == null)
{
text = Randomize.String();
}
Answer answer = _mutation.SetAnswer(
questionId: questionId,
severity: severity.GetValueOrDefault(Randomize.Severity()),
text: text,
progression: progression.GetValueOrDefault(Randomize.Progression())
);
return(answer);
}
public async Task <SaveEventResponse> SaveEventAsync(
string type,
int?code = null,
object?data = null,
DateTimeOffset?occurredAt = null,
Severity?severity = null,
string[]?tags = null,
CancellationToken cancellationToken = default
)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var requestUri = new Uri("/events", UriKind.Relative);
using var request = new HttpRequestMessage(HttpMethod.Post, requestUri)
{
Content = new JsonContent(new { code, data, occurredAt, severity, tags, type })
};
using HttpResponseMessage response = await client.SendAsync(request, cancellationToken);
string?json = null;
try
{
json = await response.Content.ReadAsStringAsync();
}
catch (Exception)
{
}
return(new SaveEventResponse
{
Error = response.IsSuccessStatusCode ? null : json,
Event = response.IsSuccessStatusCode && json != null?JsonConvert.DeserializeObject <Event>(json) : null,
StatusCode = response.StatusCode
});
}
public static void Threshold <T>(T value, Thresholds <T> thresholds, Action <Severity, T> action, IComparer <T>?comparer = null)
where T : struct
{
if (comparer == null)
{
comparer = Comparer <T> .Default;
}
Severity?severity = null;
T? threshold = null;
if (thresholds.Info != null && comparer.Compare(value, thresholds.Info.Value) >= 0)
{
severity = Severity.Info;
threshold = thresholds.Info;
}
if (thresholds.Warning != null && comparer.Compare(value, thresholds.Warning.Value) >= 0)
{
severity = Severity.Warning;
threshold = thresholds.Warning;
}
if (thresholds.Error != null && comparer.Compare(value, thresholds.Error.Value) >= 0)
{
severity = Severity.Error;
threshold = thresholds.Error;
}
if (thresholds.Fatal != null && comparer.Compare(value, thresholds.Fatal.Value) >= 0)
{
severity = Severity.Fatal;
threshold = thresholds.Fatal;
}
if (severity != null)
{
Contract.AssertNotNull(threshold);
action(severity.Value, threshold.Value);
}
}
public SyslogMessage(
string message,
Severity?severity = null,
DateTimeOffset?dateTimeOffset = null,
string hostName = DefaultHostName,
Facility?facility = null,
string appName = "",
string procId = "",
string msgId = "",
params StructuredDataElement[] structuredDataElements)
{
DateTimeOffset = dateTimeOffset ?? DateTimeOffset.Now;
Facility = facility ?? DefaultFacility;
Severity = severity ?? DefaultSeverity;
HostName = hostName;
AppName = appName;
Message = message;
ProcId = procId;
MsgId = msgId;
StructuredDataElements = structuredDataElements;
}
public static IEvent GenerateWorkorder(Telemetry telemetry, Severity?severity)
{
return(new ContosoWorkorder {
Name = "RuleWorkorder", SeverityLevel = severity, Telemetry = telemetry, Created = DateTime.UtcNow
});
}
public IFluentLoggerWriter Info()
{
_severity = Logging.Severity.Info;
return(this);
}
public static int CalculatePriorityValue(Facility?facility, Severity?severity)
{
return(((int)facility << 3) | (int)severity);
}
public SubIssueAttribute (string title, Severity severity)
{
Title = title;
this.Severity = severity;
}
public static void WriteInformation(object msg, Severity?severity = null, int?eventId = null, [CallerFilePath] string category = null, [CallerMemberName] string action = null, string sessionID = null)
{
Write(Priority.Information, severity ?? Severity.Information, msg.ToString(), eventId, category, action, sessionID);
}
public SubIssueAttribute (string title, Severity severity)
{
Title = title;
this.Severity = severity;
}
/// <inheritdoc />
public virtual TSection Trace(string sourceName, string content, Severity?severity = null)
{
return(AddPolicyDefinition(new Trace(sourceName, content, severity)));
}
public static IEvent GenerateTask(Telemetry telemetry, Severity?severity)
{
return(new ContosoTask {
Name = "CokeFridgeTask", SeverityLevel = severity, Telemetry = telemetry, Created = DateTime.UtcNow
});
}
public IFluentLoggerWriter Debug()
{
_severity = Logging.Severity.Debug;
return(this);
}
public SubIssueAttribute (string title, Severity severity, bool isEnabledByDefault)
{
Title = title;
this.Severity = severity;
this.IsEnabledByDefault = isEnabledByDefault;
}
public IValidationError BuildValidationError(string ruleName, string learnRefNumber, long?aimSequenceNumber, Severity?severity, IEnumerable <IErrorMessageParameter> errorMessageParameters)
{
return(new ValidationError(ruleName, learnRefNumber, aimSequenceNumber, severity, errorMessageParameters));
}
public SubIssueAttribute (string title, Severity severity, bool isEnabledByDefault)
{
Title = title;
this.Severity = severity;
this.IsEnabledByDefault = isEnabledByDefault;
}
public IFluentLoggerWriter Warn()
{
_severity = Logging.Severity.Warn;
return(this);
}