private async Task EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent evt) { _logger.LogTrace("EventAppeared {SubscriptionName} {Stream} Projector {ProjectorId}", sub.SubscriptionName, sub.StreamId, ProjectorId); var de = evt.Event.ToDomainEvent(); var desc = new ProjectionEventData { EventData = de, EventNumber = evt.OriginalEventNumber }; // if (_useQueue) // { // _logger.LogTrace("Enqueue Event {@0}", desc); // await Queue.EnqueueAsync(desc).ConfigureAwait(false); // } // else // { await HandleEventAsync(desc).ConfigureAwait(false); // } }
private static void LogToConsole(string message, Level logLevel, Exception ex = null) { switch (logLevel) { case Level.Error: _logger.LogError(new EventId(1), ex, message); break; case Level.Debug: _logger.LogDebug(new EventId(1), ex, message); break; case Level.Warning: _logger.LogWarning(new EventId(1), ex, message); break; case Level.Information: _logger.LogInformation(new EventId(1), ex, message); break; case Level.Verbose: _logger.LogTrace(new EventId(1), ex, message); break; default: _logger.LogDebug(new EventId(1), ex, message); break; } }
public static bool IsJsonOfTypeEventStoreData(JToken json, Microsoft.Extensions.Logging.ILogger logger) { try { if ((json["events"] != null && json["events"].Type == JTokenType.Array) || (json["Events"] != null && json["Events"].Type == JTokenType.Array)) { return(true); } } catch (Exception ex) { logger.LogTrace(ex, ex.Message); logger.LogTrace($"Json seams not to be of Type {nameof(EventStoreData)}."); } return(false); }
//private IEventStoreConnection CreateForCluster(ConnectionSettingsBuilder connectionSettingsBuilder) //{ // var endpoints = Options.ClusterIpEndpoints.Select((x, i) => // { // var ipa = GetHostIp(x); // var port = Options.TcpPort; // if (Options.ClusterHttpPorts.Length >= i + 1) port = Options.ClusterHttpPorts[i]; // _logger.LogTrace($"Creating Cluster IP Endpoint: {ipa}:{port}"); // return new IPEndPoint(ipa, port); // }); // var clusterSettings = ClusterSettings.Create() // .DiscoverClusterViaGossipSeeds() // .SetGossipTimeout(TimeSpan.FromMilliseconds(500)) // .SetGossipSeedEndPoints(endpoints.ToArray()) // ; // var con = EventStoreConnection.Create(connectionSettingsBuilder, clusterSettings); // return con; //} public IEventStoreConnection CreateNewConnection(Action <ConnectionSettingsBuilder> setup = null) { _logger.LogTrace("Creating Connection"); IEventStoreConnection con; var connectionSettingsBuilder = ConnectionSettings.Create() .KeepReconnecting() .KeepRetrying(); setup?.Invoke(connectionSettingsBuilder); //if (!Options.UseCluster) //{ var ipa = GetHostIp(Options.IpEndPoint); if (Options.UseSslCertificate) { _logger.LogInformation("Connecting To GetEventStore: with SSL IP: {0}:{1} // User: {2}", Options.IpEndPoint, Options.ExtSecureTcpPort, Options.OpsUsername); var url = $"tcp://{ipa.MapToIPv4()}:{Options.ExtSecureTcpPort}"; connectionSettingsBuilder.UseSslConnection(Options.SslTargetHost, Options.SslValidateServer); var uri = new Uri(url); con = EventStoreConnection.Create(connectionSettingsBuilder, uri); } else { _logger.LogInformation("Connecting To GetEventStore: without SSL IP: {0}:{1} // User: {2}", Options.IpEndPoint, Options.TcpPort, Options.OpsUsername); var url = $"tcp://{ipa.MapToIPv4()}:{Options.TcpPort}"; var uri = new Uri(url); con = EventStoreConnection.Create(connectionSettingsBuilder, uri); } //} //else //{ // if (Options.UseSslCertificate) // //var ipa = GetHostIp(Options.IpEndPoint); // // var url = $"tcp://{ipa.MapToIPv4()}:{Options.ExtSecureTcpPort}"; // connectionSettingsBuilder.UseSslConnection(Options.SslTargetHost, Options.SslValidateServer); // _logger.LogInformation("Connecting To GetEventStore: for Cluster // User: {0}", Options.OpsUsername); // con = CreateForCluster(connectionSettingsBuilder); //} RegisterEvents(con); //con.ConnectAsync().ConfigureAwait(false).GetAwaiter().GetResult(); return(con); }
internal async Task HandleEventAsync(ProjectionEventData entry) { _logger.LogTrace("Handled Item {EventNumber} {StreamName} {ProjectorId}", entry.EventNumber, StreamName, ProjectorId); CurrentCheckPoint = entry.EventNumber; try { await _projector.ProcessEventAsync(entry.EventData); Status.LastCheckPoint = entry.EventNumber; Status.ModifiedOnUtc = DateTime.UtcNow; await EntityStore.UpdateItemAsync(Status, _cancellationToken); } catch (Exception e) { _logger.LogError(e, "Error while Processing Event {EventNumber} from {StreamName} {ProjectorId}", entry.EventNumber, StreamName, ProjectorId); throw; } }
private void DumpEnv() { _log.LogDebug($"appBaseDir=[{_appBaseDir}]"); _log.LogDebug($"procModDir=[{_procModDir}]"); var env = Environment.GetEnvironmentVariables(); foreach (var envKey in env.Keys.Cast <string>().OrderBy(x => x)) { _log.LogTrace($"* [{envKey}]=[{env[envKey]}]"); } }
public async Task <bool> CheckAggregateExists <T>(string aggregateId, string streamName) where T : AggregateRoot { _logger.LogDebug("CheckAggregateExists {type} {AggregateId} {StreamName}", typeof(T), aggregateId, streamName); //var sliceStart = 1; //Ignores $StreamCreated long sliceStart = 0; //Ignores $StreamCreated var con = await _provider.GetActiveConnection(); var currentSlice = await con .ReadStreamEventsForwardAsync(streamName, sliceStart, 1, false, _provider.OpsCredentials) .ConfigureAwait(false); if (currentSlice.Status == SliceReadStatus.StreamNotFound) { _logger.LogTrace("CheckAggregateExists {type} {AggregateId} {StreamName} not found", typeof(T), aggregateId, streamName); return(false); } return(true); }
private static async Task <RTCPeerConnection> CreatePeerConnection() { RTCConfiguration config = new RTCConfiguration { X_DisableExtendedMasterSecretKey = true }; var pc = new RTCPeerConnection(config); MediaStreamTrack audioTrack = new MediaStreamTrack(SDPWellKnownMediaFormatsEnum.PCMU); pc.addTrack(audioTrack); var dc = await pc.createDataChannel("sipsocery-dc"); pc.onicecandidateerror += (candidate, error) => logger.LogWarning($"Error adding remote ICE candidate. {error} {candidate}"); pc.OnTimeout += (mediaType) => logger.LogWarning($"Timeout for {mediaType}."); pc.oniceconnectionstatechange += (state) => logger.LogInformation($"ICE connection state changed to {state}."); pc.onsignalingstatechange += () => logger.LogInformation($"Signaling state changed to {pc.signalingState}."); pc.OnReceiveReport += (re, media, rr) => logger.LogDebug($"RTCP Receive for {media} from {re}\n{rr.GetDebugSummary()}"); pc.OnSendReport += (media, sr) => logger.LogDebug($"RTCP Send for {media}\n{sr.GetDebugSummary()}"); pc.OnRtcpBye += (reason) => logger.LogDebug($"RTCP BYE receive, reason: {(string.IsNullOrWhiteSpace(reason) ? "<none>" : reason)}."); pc.onsignalingstatechange += () => { if (pc.signalingState == RTCSignalingState.have_remote_offer) { logger.LogTrace("Remote SDP:"); logger.LogTrace(pc.remoteDescription.sdp.ToString()); } else if (pc.signalingState == RTCSignalingState.have_local_offer) { logger.LogTrace("Local SDP:"); logger.LogTrace(pc.localDescription.sdp.ToString()); } }; return(pc); }
public void DoSomeStuff() { var position1 = new { A = 1 }; var position2 = new { B = 2 }; using (_logger.BeginScope("my scope")) { _logger.LogTrace("Trace"); _logger.LogDebug("Debug"); _logger.LogInformation("Processed {Position1} {Position2}", position1, position2); _logger.LogWarning("Warning"); _logger.LogError("Error"); _logger.LogCritical("Critical error"); } }
public void Execute(string[] args) { _logger.LogTrace("TestTrace"); _logger.LogInformation("Starting"); var startTime = DateTimeOffset.Now; _logger.LogInformation(1, "Started at '{StartTime}' and 0x{Hello:X} is hex of 42", startTime, 42); // or _logger.ProgramStarting(startTime, 42); using (_logger.PurchaseOrderScope("00655321")) { try { throw new Exception("Boom"); } catch (Exception ex) { _logger.LogCritical(1, ex, "Unexpected critical error starting application"); _logger.LogError(1, ex, "Unexpected error"); _logger.LogWarning(1, ex, "Unexpected warning"); } using (_logger.BeginScope("Main")) { _logger.LogInformation("Waiting for user input"); string input; do {//这段代码有些问题,打印的顺序不固定。原因不明。test2 Console.WriteLine("Enter some test to log more, or 'quit' to exit."); input = Console.ReadLine(); _logger.LogInformation("User typed '{input}' on the command line", input); _logger.LogWarning("The time is now {Time}, it's getting late!", DateTimeOffset.Now); }while (input != "quit"); } } var endTime = DateTimeOffset.Now; _logger.LogInformation(2, "Stopping at '{StopTime}'", endTime); // or _logger.ProgramStopping(endTime); _logger.LogInformation("Stopping"); }
public override void Log(ILogMessage message) { if (message.Message.Contains("Resolving dependency information took")) { return; } if (message.Message.Trim().StartsWith("CACHE")) { return; } var level = message.Level; var text = message.Message; switch (level) { // ReSharper disable TemplateIsNotCompileTimeConstantProblem case LogLevel.Debug: m_Logger.LogDebug(text); break; case LogLevel.Verbose: m_Logger.LogTrace(text); break; case LogLevel.Information: m_Logger.LogInformation(text); break; case LogLevel.Minimal: m_Logger.LogInformation(text); break; case LogLevel.Warning: m_Logger.LogWarning(text); break; case LogLevel.Error: m_Logger.LogError(text); break; // ReSharper restore TemplateIsNotCompileTimeConstantProblem default: throw new ArgumentOutOfRangeException(nameof(level), level, null); } }
public override void Log(ILogMessage message) { if (message.Message.Contains("Resolving dependency information took")) { return; } if (message.Message.Trim().StartsWith("CACHE")) { return; } var level = message.Level; string prefix = "[NuGet] "; var text = prefix + message.Message; switch (level) { case LogLevel.Debug: m_Logger.LogDebug(text); break; case LogLevel.Verbose: m_Logger.LogTrace(text); break; case LogLevel.Information: m_Logger.LogInformation(text); break; case LogLevel.Minimal: m_Logger.LogInformation(text); break; case LogLevel.Warning: m_Logger.LogWarning(text); break; case LogLevel.Error: m_Logger.LogError(text); break; default: throw new ArgumentOutOfRangeException(nameof(level), level, null); } }
public void Write(EventType eventType, Func <string> logMessage) { switch (eventType) { case EventType.Trace: netCoreLogger.LogTrace(logMessage()); break; case EventType.Info: netCoreLogger.LogInformation(logMessage()); break; case EventType.Error: netCoreLogger.LogError(logMessage()); break; } }
private async Task <string> LoadJsonAsync(string name, string partitionId) { var manager = _provider.CreateProjectionsManager(); string json; if (string.IsNullOrEmpty(partitionId)) { json = await manager.GetStateAsync(name, _provider.OpsCredentials).ConfigureAwait(false); } else { json = await manager.GetPartitionStateAsync(name, partitionId, _provider.OpsCredentials).ConfigureAwait(false); } _logger.LogTrace("State {StateJson}", json); return(json); }
private static void HexLoggingFormatter(Microsoft.Extensions.Logging.ILogger logger, string method, ReadOnlySpan <byte> buffer) { if (!logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Trace)) { return; } var builder = new StringBuilder($"{method}[{buffer.Length}] "); // Write the hex foreach (var b in buffer) { builder.Append(b.ToString("X2")); builder.Append(" "); } logger.LogTrace(builder.ToString()); }
static void WriteLog(ILogger logger, LogLevel logLevel, string message) { if (logger == null) { Console.WriteLine($"{logLevel}: {message}"); } else { switch (logLevel) { case LogLevel.Trace: logger.LogTrace(message); break; case LogLevel.Debug: logger.LogDebug(message); break; case LogLevel.Information: logger.LogInformation(message); break; case LogLevel.Warning: logger.LogWarning(message); break; case LogLevel.Error: logger.LogCritical(message); break; case LogLevel.Critical: logger.LogCritical(message); break; default: break; } } }
public override void Log(ILogMessage message) { var level = message.Level; string prefix = "[NuGet] "; var text = prefix + message.Message; switch (level) { case LogLevel.Debug: m_Logger.LogDebug(text); break; case LogLevel.Verbose: m_Logger.LogTrace(text); break; case LogLevel.Information: m_Logger.LogInformation(text); break; case LogLevel.Minimal: m_Logger.LogInformation(text); break; case LogLevel.Warning: m_Logger.LogWarning(text); break; case LogLevel.Error: m_Logger.LogError(text); break; default: throw new ArgumentOutOfRangeException(nameof(level), level, null); } }
public void Log(string message) { _logger.LogTrace(message); }
public static IWebHostBuilder CreateWebHostBuilder(string[] args) { bool all = args.Contains("all", StringComparer.OrdinalIgnoreCase); bool sample1 = all || args.Contains("sample1", StringComparer.OrdinalIgnoreCase); bool sample2 = all || args.Contains("sample2", StringComparer.OrdinalIgnoreCase); bool everyMinute = all || args.Contains("everyMinute", StringComparer.OrdinalIgnoreCase); bool evenMinutes = all || args.Contains("evenMinutes", StringComparer.OrdinalIgnoreCase); var loggerFactory = new SerilogLoggerFactory(new LoggerConfiguration() .MinimumLevel.Verbose() .WriteTo.Console() .CreateLogger()); _logger = loggerFactory.CreateLogger <Program>(); var builder = WebHost.CreateDefaultBuilder(args) .SuppressStatusMessages(true) .ConfigureServices(s => { s.AddSingleton <ILoggerFactory>(loggerFactory); // will shutdown the host if no jobs are running s.AddJobLifetimeService(); // inserts a startup action that does not complete until the critical health checks are healthy // gets inserted as 1st startup action so that any other startup actions dont run until the critical resources are available s.AddStartupActionToWaitForHealthChecks("Critical"); s.AddHealthChecks().AddCheck <MyCriticalHealthCheck>("My Critical Resource", tags: new[] { "Critical" }); // add health check that does not return healthy until the startup actions have completed // useful for readiness checks s.AddHealthChecks().AddCheckForStartupActions("Critical"); if (everyMinute) { s.AddCronJob <EveryMinuteJob>("* * * * *"); } if (evenMinutes) { s.AddCronJob <EvenMinutesJob>("*/2 * * * *"); } if (sample1) { s.AddJob(sp => new Sample1Job(sp.GetRequiredService <ILoggerFactory>()), o => o.ApplyDefaults <Sample1Job>().WaitForStartupActions(true).InitialDelay(TimeSpan.FromSeconds(5))); } if (sample2) { s.AddHealthChecks().AddCheck <Sample2Job>("Sample2Job"); s.AddJob <Sample2Job>(true); } // if you don't specify priority, actions will automatically be assigned an incrementing priority starting at 0 s.AddStartupAction("Test1", async() => { _logger.LogTrace("Running startup 1 action."); for (int i = 0; i < 3; i++) { await Task.Delay(1000); _logger.LogTrace("Running startup 1 action..."); } _logger.LogTrace("Done running startup 1 action."); }); // then these startup actions will run concurrently since they both have the same priority s.AddStartupAction <MyStartupAction>(priority: 100); s.AddStartupAction <OtherStartupAction>(priority: 100); s.AddStartupAction("Test2", async() => { _logger.LogTrace("Running startup 2 action."); for (int i = 0; i < 2; i++) { await Task.Delay(1500); _logger.LogTrace("Running startup 2 action..."); } //throw new ApplicationException("Boom goes the startup."); _logger.LogTrace("Done running startup 2 action."); }); //s.AddStartupAction("Boom", () => throw new ApplicationException("Boom goes the startup")); }) .Configure(app => { app.UseHealthChecks("/health"); app.UseReadyHealthChecks("Critical"); // this middleware will return Service Unavailable until the startup actions have completed app.UseWaitForStartupActionsBeforeServingRequests(); // add mvc or other request middleware after the UseWaitForStartupActionsBeforeServingRequests call }); return(builder); }
public async Task AddOpsUserToAdminsAsync() { _logger.LogTrace("AddOpsUserToAdminsAsync"); if (await CheckOpsUserIsInAdminGroupAsync().ConfigureAwait(false)) { _logger.LogTrace("ops user is already admin"); return; } var manager = _provider.CreateUsersManager(); var ops = await manager.GetUserAsync("ops", _provider.AdminCredentials).ConfigureAwait(false); if (ops.Groups == null || ops.Groups != null && !ops.Groups.Contains("$admins")) { var groups = new List <string>(); if (ops.Groups != null) { groups.AddRange(ops.Groups); } groups.Add("$admins"); await manager.UpdateUserAsync("ops", ops.FullName, groups.ToArray(), _provider.AdminCredentials) .ConfigureAwait(false); _logger.LogTrace("Group $admin added to ops user"); } }
public void Trace(object message) { _extLogger.LogTrace(message.ToString()); }
public async Task <RTCSessionDescriptionInit> GotOffer(RTCSessionDescriptionInit offer) { logger.LogTrace($"SDP offer received."); logger.LogTrace(offer.sdp); var pc = new RTCPeerConnection(); if (_presetIceAddresses != null) { foreach (var addr in _presetIceAddresses) { var rtpPort = pc.GetRtpChannel().RTPPort; var publicIPv4Candidate = new RTCIceCandidate(RTCIceProtocol.udp, addr, (ushort)rtpPort, RTCIceCandidateType.host); pc.addLocalIceCandidate(publicIPv4Candidate); } } MediaStreamTrack audioTrack = new MediaStreamTrack(SDPWellKnownMediaFormatsEnum.PCMU); pc.addTrack(audioTrack); MediaStreamTrack videoTrack = new MediaStreamTrack(new VideoFormat(VideoCodecsEnum.VP8, VP8_PAYLOAD_ID)); pc.addTrack(videoTrack); pc.OnRtpPacketReceived += (IPEndPoint rep, SDPMediaTypesEnum media, RTPPacket rtpPkt) => { pc.SendRtpRaw(media, rtpPkt.Payload, rtpPkt.Header.Timestamp, rtpPkt.Header.MarkerBit, rtpPkt.Header.PayloadType); }; pc.OnTimeout += (mediaType) => logger.LogWarning($"Timeout for {mediaType}."); pc.oniceconnectionstatechange += (state) => logger.LogInformation($"ICE connection state changed to {state}."); pc.onsignalingstatechange += () => logger.LogInformation($"Signaling state changed to {pc.signalingState}."); pc.onconnectionstatechange += (state) => { logger.LogInformation($"Peer connection state changed to {state}."); if (state == RTCPeerConnectionState.failed) { pc.Close("ice failure"); } }; var setResult = pc.setRemoteDescription(offer); if (setResult == SetDescriptionResultEnum.OK) { var offerSdp = pc.createOffer(null); await pc.setLocalDescription(offerSdp); var answer = pc.createAnswer(null); logger.LogTrace($"SDP answer created."); logger.LogTrace(answer.sdp); return(answer); } else { logger.LogWarning($"Failed to set remote description {setResult}."); return(null); } }
public void LogTrace(string message, params object[] args) => logger.LogTrace(message, args);
public void Trace(string message) { _readLogger.LogTrace(message); }
/// <summary>Logs exception with trace log level.</summary> /// <remarks><para>See <see cref="ExceptionLoggingHelper"/> for more information.</para> /// <para>This method is null-logger-safe - if <paramref name="log"/> is null, message and exception won't be logged.</para></remarks> /// <param name="exception">Exception message to log.</param> /// <param name="log">Logger instance.</param> /// <param name="message">Log message template.</param> /// <param name="args">Structured log message arguments.</param> /// <returns>Always returns true.</returns> public static bool LogAsTrace(this Exception exception, ILogger log, string message, params object[] args) { log?.LogTrace(exception, message, args); return(true); }
private void Handle_Reconnecting(object sender, ClientReconnectingEventArgs e) { _logger?.LogTrace($"Reconnecting: {e.Connection.ConnectionName}"); Reconnecting?.Invoke(sender, e); }
public void CreateDirectory(string filePath) { Logger.LogTrace("CreateDirectory called"); filePath = filePath?.Replace("\\", "/"); RootFs.CreateDirectoryAsync(filePath).ConfigureAwait(false).GetAwaiter().GetResult(); }
public static void LogTrace(this ILogger logger, Object obj, string message, params object[] args) { Log(logger, obj, () => logger.LogTrace(message, args)); }