public PersistOnEventRequest(long persistOnEventSequenceNr, EventId?persistOnEventId, ImmutableArray <PersistOnEventInvocation> invocations, int instanceId)
{
PersistOnEventSequenceNr = persistOnEventSequenceNr;
PersistOnEventId = persistOnEventId;
Invocations = invocations;
InstanceId = instanceId;
}
/// <summary>Initializes a new instance of the <see cref="Error"/> class.</summary>
/// <param name="errorMessage">The error message.</param>
/// <param name="innerError">The inner error.</param>
/// <param name="eventId">The event identifier.</param>
internal Error([NotNull] string errorMessage, [CanBeNull] IError innerError = null, [CanBeNull] EventId?eventId = null)
: this()
{
ErrorMessage = errorMessage;
InnerError = innerError;
ErrorEventId = eventId;
}
/// <summary>
/// Init new instance of LazyEvaluatedError
/// </summary>
/// <param name="progrId">Int identifier of function in error</param>
/// <param name="errorMessage">Error message (useful for logging)</param>
/// <param name="outputMessage">Optional Message to Service that received the error</param>
/// <param name="errorEventId">Event Id for this error</param>
/// <param name="innerError">Inner Error</param>
public LazyEvaluatedError(int progrId, [NotNull] string errorMessage, [CanBeNull] string outputMessage, EventId?errorEventId, [CanBeNull] IError innerError = null)
: base(errorMessage, innerError)
{
ProgrId = progrId;
OutputMessage = outputMessage;
ErrorEventId = errorEventId;
}
public DurableEvent(object payload,
string emitterId = null,
string emitterAggregateId = null,
ImmutableHashSet <string> customDestinationAggregateIds = null,
DateTime systemTimestamp = default,
VectorTime vectorTimestamp = null,
string processId = null,
string localLogId = null,
long localSequenceNr = 0,
string deliveryId = null,
long?persistOnEventSequenceNr = null,
EventId?persistOnEventId = null)
{
Payload = payload;
EmitterId = emitterId ?? UndefinedEmittedId;
EmitterAggregateId = emitterAggregateId;
CustomDestinationAggregateIds = customDestinationAggregateIds ?? ImmutableHashSet <string> .Empty;
SystemTimestamp = systemTimestamp;
VectorTimestamp = vectorTimestamp ?? VectorTime.Zero;
ProcessId = processId ?? UndefinedLogId;
LocalLogId = localLogId ?? UndefinedLogId;
LocalSequenceNr = localSequenceNr;
DeliveryId = deliveryId;
PersistOnEventSequenceNr = persistOnEventSequenceNr;
PersistOnEventId = persistOnEventId;
Id = new EventId(ProcessId, VectorTimestamp[ProcessId]);
}
internal static StringBuilder PrepareValidationFailures([NotNull] ValidationResult fluentValidationResult,
EventId?eventId, [NotNull] out Error[] errors)
{
StringBuilder sb = new StringBuilder();
var errs = new List <Error>();
foreach (var failure in fluentValidationResult.Errors)
{
string msg = $"{failure.ErrorMessage}; ";
if (!StringExtensions.IsNullString(failure.PropertyName) && failure.PropertyName != "*")
{
msg = $"PropertyName '{failure.PropertyName}' - ErrorMessage '{failure.ErrorMessage}'; ";
}
sb.Append(msg);
//errs.Add(Error.Parse(msg, eventId));
errs.Add(new Error(msg)
{
ErrorEventId = eventId
});
}
errors = errs.ToArray();
return(sb);
}
public static void Expects <TException>(bool state, string errorMessage, EventId?tagId)
where TException : Exception
{
if (!Validate(state, errorMessage, tagId))
{
ReportError <TException>(errorMessage);
}
}
public static bool Validate(bool state, EventId?tagId, string errorMessage, params object[] parameters)
{
if (!state)
{
LogError(tagId, errorMessage, parameters);
}
return(state);
}
public static bool Validate(bool state, string errorMessage, EventId?tagId)
{
if (!state)
{
LogError(tagId, errorMessage);
}
return(state);
}
public WarningAsErrorContext(
ILoggerFactory sink = null,
EventId?toLog = null,
EventId?toThrow = null)
{
_sink = sink;
_toLog = toLog;
_toThrow = toThrow;
}
public WarningAsErrorContext(
IList <string> sink = null,
EventId?toLog = null,
EventId?toThrow = null)
{
_sink = sink;
_toLog = toLog;
_toThrow = toThrow;
}
public static bool ValidateArgument(Guid argumentValue, string argumentName, EventId?tagId = null)
{
if (argumentValue.Equals(Guid.Empty))
{
LogError(tagId, ValidationFailed, ArgumentIsEmptyGuid, argumentName);
return(false);
}
return(true);
}
/// <summary>
/// Assert that the values are as expected.
/// </summary>
/// <param name="logLevel">Log Level</param>
/// <param name="eventId">Event ID</param>
/// <param name="exception">Exception</param>
/// <param name="message">Formatted Message</param>
public void Assert(LogLevel?logLevel, EventId?eventId, Exception exception, string message)
{
Xunit.Assert.Equal(LogLevel, LogLevel);
Xunit.Assert.Equal(eventId, EventId);
Xunit.Assert.Equal(exception, Exception);
Xunit.Assert.Equal(message, Message);
Xunit.Assert.True(IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug));
using (var scope = BeginScope("Test"))
Xunit.Assert.IsAssignableFrom <IDisposable>(scope);
}
/// <summary>
/// Determines whether this instance of <see cref="EventId"/> refers to the same event as <paramref name="other"/>.
/// </summary>
public bool Equals(EventId?other)
{
if (ReferenceEquals(this, other))
{
return(true);
}
return(other != null &&
DefiningType.Equals(other.DefiningType) &&
StringComparer.Ordinal.Equals(Name, other.Name));
}
public WarningAsErrorContext(
IServiceProvider serviceProvider,
bool defaultThrow = true,
EventId?toLog = null,
EventId?toThrow = null)
{
_serviceProvider = serviceProvider;
_defaultThrow = defaultThrow;
_toLog = toLog;
_toThrow = toThrow;
}
protected async Task <Stream> ExecuteRequestWithStreamResult(string url, EventId?eventId)
{
var response = await ExecuteGetRequest(url, eventId);
if (response.IsSuccessStatusCode)
{
return(await response.Content.ReadAsStreamAsync());
}
else
{
return(null);
}
}
//------------------------------------------TRACE------------------------------------------//
public static void Trace(
#if !NET20
this
#endif
ILogger logger, string message, EventId?eventId = null, Exception exception = null)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
logger.Log(LogLevel.Trace, eventId == null ? 0 : eventId.Value, exception, message);
}
private static void LogError(EventId?eventId, string message, params object[] args)
{
if (!eventId.HasValue)
{
return;
}
if (s_logger == null)
{
throw new OmexCompatibilityInitializationException();
}
s_logger.LogError(eventId.Value, message, args);
}
public async Task <Response <(IReadOnlyList <AuditEntry> Entries, int Count)> > GetAuditEntries(
int skip, int take, EventType?eventType = null, EventId?eventId = null)
{
try
{
var connStr = _configuration.GetConnectionString(Constants.DbConnectionName);
await using var conn = new SqlConnection(connStr);
var sql = @"SELECT al.EventId,
al.EventType,
al.EventTimeUtc,
al.[Message],
al.WebUsername as [Username],
al.IpAddressV4,
al.MachineName
FROM AuditLog al
WITH(NOLOCK)
WHERE 1 = 1
AND (@EventType IS NULL OR al.EventType = @EventType)
AND (@EventId IS NULL OR al.EventId = @EventId)
ORDER BY al.EventTimeUtc DESC
OFFSET @Skip ROWS
FETCH NEXT @Take ROWS ONLY
SELECT COUNT(al.Id)
FROM AuditLog al
WHERE 1 = 1
AND(@EventType IS NULL OR al.EventType = @EventType)
AND(@EventId IS NULL OR al.EventId = @EventId);";
using var multi = await conn.QueryMultipleAsync(sql, new
{
eventType,
eventId,
skip,
take
});
var entries = multi.Read <AuditEntry>().ToList();
var count = multi.ReadFirstOrDefault <int>();
var returnType = (entries, count);
return(new SuccessResponse <(IReadOnlyList <AuditEntry> Entries, int Count)>(returnType));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(new FailedResponse <(IReadOnlyList <AuditEntry> Entries, int Count)>((int)ResponseFailureCode.GeneralException, e.Message, e));
}
}
public static Error FromException([NotNull] Exception exception, EventId?eventId = null)
{
Error r = null;
r = null == exception.InnerException
? new MainErrorFromException(exception.StackTrace, exception.Message)
: new Error(exception.Message);
if (null != eventId)
{
r.ErrorEventId = eventId;
}
if (null != exception.InnerException)
{
r.InnerError = FromException(exception.InnerException);
}
return(r);
}
protected async Task <HttpResponseMessage> ExecuteGetRequest(string url, EventId?eventId)
{
bool releaseId = false;
var logId = eventId != null ? (EventId)eventId : LogEventIdProvider.GetRandomLogEventId();
lastAPIRequest = DateTime.UtcNow;
if (eventId == null)
{
releaseId = true;
}
try
{
using (var client = new HttpClient())
{
_logger.LogDebug(logId, LogMessageBuilder.Build(logId, $"Executing Request to {url}"));
client.DefaultRequestHeaders.Add("User-Agent", $"NationStatesApiBot/{AppSettings.VERSION}");
client.DefaultRequestHeaders.Add("User-Agent", $"(contact { _config.Contact};)");
var response = await client.GetAsync(url);
if (!response.IsSuccessStatusCode)
{
_logger.LogError(logId, LogMessageBuilder.Build(logId, $"Request finished with response: {(int)response.StatusCode}: {response.ReasonPhrase}"));
}
else
{
_logger.LogDebug(logId, LogMessageBuilder.Build(logId, $"Request finished with response: {(int)response.StatusCode}: {response.ReasonPhrase}"));
}
if ((int)response.StatusCode == 429)
{
_logger.LogDebug(logId, LogMessageBuilder.Build(logId, $"Retry in {response.Headers.RetryAfter.Delta} seconds."));
}
return(response);
}
}
finally
{
if (releaseId)
{
LogEventIdProvider.ReleaseEventId(logId);
}
}
}
public static Error FromException([NotNull] Exception exception, EventId?eventId = null)
{
if (null == exception)
{
throw new ArgumentNullException(nameof(exception));
}
var e = new Error(exception.Message);
if (null != eventId)
{
e.ErrorEventId = eventId;
}
if (null != exception.InnerException)
{
e.InnerError = FromException(exception.InnerException);
}
return(e);
}
public LogEntry With(
ILogSeverity severity = null,
DateTime?moment = null,
LogSource source = null,
Guid?sequenceId = null,
EventId?eventId = null,
Object data = null,
IDictionary <String, Object> metadata = null,
Exception exception = null
) =>
new LogEntry(
severity ?? Severity,
moment ?? Moment,
source ?? Source,
sequenceId ?? SequenceId,
eventId ?? EventId,
data ?? Data,
metadata ?? Metadata,
exception ?? Exception
);
//public ILogMessageEntry Create(LogLevel logLevel)
//{
// return Create(logLevel, null);
//}
//public ILogMessageEntry Create(LogLevel logLevel, string message)
//{
// return new LogEnrtyEx(logLevel, message);
//}
public ILogMessageEntry Create(DateTimeOffset now, LogLevel logLevel, string category, string message, EventId?eventId = null, string correlationid = null, Exception ex = null)
{
return(new LogEnrtyEx(logLevel, message)
{
Timestamp = now,
Category = category,
EventId = eventId,
CorrelationId = correlationid,
Exception = ex,
});
}
public WarningAsErrorContext(
IServiceProvider serviceProvider,
bool defaultThrow = true,
EventId?toLog = null,
EventId?toThrow = null,
(EventId Id, LogLevel Level)?toChangeLevel = null)
internal static Event Single(EventId?id = null, int sequenceSeed = 0) => Event.New(Strings.Random(), id ?? EventId.New(), sequenceSeed == 0 ? Sequence.First : Sequence.First.Add(sequenceSeed));
/// <summary>Fail result</summary>
/// <typeparam name="T">Type of the Content</typeparam>
/// <param name="identifier">The identifier.</param>
/// <param name="exception">The exception.</param>
/// <param name="eventId">The event identifier.</param>
/// <returns>Result FAIL</returns>
public static IResult <T> Fail <T>([NotNull] IIdentifier identifier, [NotNull] Exception exception
, [CanBeNull] EventId?eventId = null)
=> Fail <T>(identifier, Error.FromException(exception, eventId));
internal static IResult <TContent> FailLazyEvaluatedFunctionFromException <TContent>(int progrId, [NotNull] IIdentifier identifier
, Exception exception, EventId?eventId = null, [CanBeNull] string errorMessage = null, [CanBeNull] string outputMessage = null)
{
var msg = string.IsNullOrEmpty(errorMessage) ? exception.Message : errorMessage;
var err0 = Error.FromException(exception, eventId);
var err = new LazyEvaluatedError(progrId, msg, outputMessage, eventId, err0);
return(Fail <TContent>(identifier, err));
}
public static IResult <T> FailFromException <T>([NotNull] IIdentifier identifier, Exception ex, EventId?eventId = null, [CanBeNull] string errorMessage = null, [CanBeNull] string outputMessage = null)
{
//var msg = string.IsNullOrEmpty(errorMessage) ? ex.Message : errorMessage;
//var err = new Error(msg, outputMessage, eventId) {Exception = ex};
//return new Result<T>(identifier, new []{ err });
var err = Error.FromException(ex, eventId);
err.OutputMessage = outputMessage;
return(new Result <T>(identifier, err));
}
/// <summary>
/// Sends a log message to the console using the DSharpPlus logger.
/// </summary>
/// <param name="discordClient"></param>
/// <param name="message">Message to be displayed on the console.</param>
/// <param name="exception">Exception if the message is an error.</param>
/// <param name="logLevel">The message level, the default is <see cref="LogLevel.Information"/>.</param>
/// <exception cref="NullReferenceException"></exception>
public static void LogMessage(this DiscordClient discordClient, string message, Exception exception = null, LogLevel logLevel = LogLevel.Information, EventId?eventId = null)
{
discordClient.IsNotNull();
message.IsNotNull();
discordClient.Logger.Log(logLevel, eventId ?? default, exception, message);
}
public string Bind(string categoryName, LogLevel logLevel, EventId?eventId, string message,
Exception?exception, object[]?scopes)
{
TryGetArgumentValue valueProvider = delegate(string name, out object?value)
{
switch (name.ToUpperInvariant())
{
case "EVENTTYPE":
case "LOGLEVEL":
value = logLevel;
break;
case "SHORTLEVEL":
case "SHORTLOGLEVEL":
value = GetShortLogLevel(logLevel);
break;
case "FACILITY":
value = Facility;
break;
case "SEVERITY":
value = GetSeverity(logLevel);
break;
case "PRI":
case "PRIORITY":
value = Facility * 8 + GetSeverity(logLevel);
break;
case "ID":
value = eventId?.Id;
break;
case "EVENTID":
value = eventId?.ToString();
break;
case "MESSAGE":
value = message;
break;
case "MESSAGEPREFIX":
value = FormatPrefix(message);
break;
case "SOURCE":
case "CATEGORY":
case "CATEGORYNAME":
value = categoryName;
break;
case "EXCEPTIONMESSAGE":
value = exception?.Message;
break;
case "EXCEPTION":
value = exception;
break;
case "SCOPES":
value = FormatScopes(scopes);
break;
case "SCOPELIST":
value = FormatScopes(scopes, " => ", " => ");
break;
default:
if (!_systemValueProvider.TryGetArgumentValue(name, out value))
{
value = "{" + name + "}";
}
break;
}
return(true);
};
var result = StringTemplate.Format(Template, valueProvider);
return(result);
}