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); }