public IEnumerable<DataDogEvent> Convert(INimatorResult result)
{
if (!result.LayerResults.Any())
{
yield return ConvertToDataDogEvent(result.Level,
result.GetFirstFailedLayerName(),
result.GetFirstFailedCheckName(),
result.Message, result.RenderPlainText(settings.Threshold));
yield break;
}
var layerResults = result.LayerResults.Where(l => l?.Level >= settings.Threshold);
foreach (var layerResult in layerResults)
{
var layerName = layerResult.LayerName;
var checkResults = layerResult.CheckResults.Where(c => c?.Level >= settings.Threshold);
foreach (var checkResult in checkResults)
{
yield return ConvertToDataDogEvent(checkResult.Level,
layerName,
checkResult.CheckName,
checkResult.RenderPlainText());
}
}
}
/// <inheritdoc/>
public OpsGenieAlertRequest Convert(INimatorResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
var message = string.IsNullOrEmpty(result.Message) ?
"Unknown message" :
result.Message.Truncate(MaxOpsgenieMessageLength);
var failingLayerName = result.GetFirstFailedLayerName() ?? "UnknownLayer";
return(new OpsGenieAlertRequest(message)
{
Alias = "nimator-failure",
Description = result.RenderPlainText(settings.Threshold).Truncate(MaxOpsgenieDescriptionLength),
Responders = new[]
{
new OpsGenieResponder
{
Type = OpsGenieResponderType.Team,
Name = settings.TeamName
}
},
Tags = new[] { "Nimator", failingLayerName.Truncate(MaxOpsgenieTagLength) }
});
}
public void Notify(INimatorResult result)
{
if (result.Level >= settings.Threshold)
{
writeLine(result.RenderPlainText(settings.Threshold));
}
}
public void IntegrationWithDatabaseAndNimator()
{
//Arrange
var logger = A.Dummy <ILog>();
var notifier = A.Fake <INotifier>();
NotifierMockSettings.Notifier = notifier;
var nimatorSettingsJson = EmbeddedResource.Read("config.json");
var nimator = Nimator.FromSettings(logger, nimatorSettingsJson);
INimatorResult nimatorResult = null;
A.CallTo(() => notifier.Notify(A <INimatorResult> ._))
.Invokes(call => nimatorResult = (INimatorResult)call.Arguments[0]);
//Act
nimator.TickSafe(logger);
//Assert
nimatorResult.Should().NotBeNull();
A.CallTo(() => notifier.Notify(A <INimatorResult> ._)).MustHaveHappened();
nimatorResult.Level.Should()
.Be(NotificationLevel.Warning);
var layerResult = nimatorResult.LayerResults.Should().ContainSingle().Subject;
layerResult.CheckResults.Should().HaveCount(2)
.And.ContainSingle(r => r.CheckName == "DocumentsNumberCheck" && r.Level == NotificationLevel.Warning)
.And.ContainSingle(r => r.CheckName == "RamUsageCheck" && r.Level == NotificationLevel.Okay);
}
public void Notify(INimatorResult result)
{
SendHeartbeat();
if (result.Level >= settings.Threshold)
{
NotifyFailureResult(result);
}
}
/// <inheritdoc/>
public void Notify(INimatorResult result)
{
client.SendHeartbeat();
if (result.Level >= settings.Threshold)
{
var request = converter.Convert(result);
client.SendAlert(request);
}
}
private void NotifyFailureResult(INimatorResult result)
{
var failingLayerName = (result.GetFirstFailedLayerName() ?? "UnknownLayer").Truncate(MaxOpsgenieTagLength);
var message = result.Message.Truncate(MaxOpsgenieMessageLength);
var request = new OpsGenieCreateAlertRequest(this.settings.ApiKey, message)
{
Alias = "nimator-failure",
Description = result.RenderPlainText(settings.Threshold),
Teams = new[] { this.settings.TeamName },
Tags = new[] { "Nimator", failingLayerName }
};
SimpleRestUtils.PostToRestApi(AlertUrl, request);
}
private void SendDataDogHealthMetrics(INimatorResult nimatorResult)
{
foreach (var resultLayerResult in nimatorResult.LayerResults)
{
foreach (var checkResult in resultLayerResult.CheckResults)
{
string[] tags = new string[]
{
$"layer:{resultLayerResult.LayerName}",
$"level:{checkResult.Level.ToString()}"
};
SendCheckResultToDataDog(checkResult, tags);
SendIsHealthyToDataDog(checkResult, tags);
}
}
}
public void Notify(INimatorResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (result.Level >= _settings.Threshold)
{
foreach (var dataDogEvent in _dataDogEventConverter.Convert(result))
{
NotifyDataDogEvent(dataDogEvent);
}
}
SendDataDogHealthMetrics(result);
}
public SlackMessage(INimatorResult result, NotificationLevel minLevelForDetails, string sourceEnvironment)
{
// Because "text" will be shown (a) full-width and (b) full height without
// a 'Show More...' link, we prefer that to use for the full description.
// The "attachments" will then be a simpler things, drawing attention with
// specific coloring and icons.
Text = GetEnvironmentMessage(sourceEnvironment)
+ result.Message
+ $":\n```{result.RenderPlainText(minLevelForDetails)}```";
SlackMessageAttachments = new[]
{
new SlackMessageAttachment
{
Text = CallToActionForLevel(result.Level),
Color = GetHexForLevel(result.Level)
}
};
}
public void Notify(INimatorResult result)
{
if (settings.DebounceTimeInSecs > 0 && DateTime.Now < dontAlertBefore)
{
return;
}
if (result.Level >= settings.Threshold)
{
var message = new SlackMessage(result, settings.Threshold, settings.SourceEnvironment);
if (settings.DebounceTimeInSecs > 0)
{
dontAlertBefore = DateTime.Now.AddSeconds(settings.DebounceTimeInSecs);
message.AddAttachment("Debouncing messages until at least *" + dontAlertBefore.ToString("yyyy-MM-dd, HH:mm:ss") + "*, even if more problems arise.");
}
SimpleRestUtils.PostToRestApi(settings.Url, message);
}
}
