/// <summary> /// Logs an info exception. /// </summary> /// <param name="log">The log.</param> /// <param name="e">The exception.</param> public static void LogInfo(this INeonLogger log, Exception e) { if (log.IsInfoEnabled) { log.LogInfo(null, e); } }
/// <summary> /// Logs a warning message retrieved via a message function. /// </summary> /// <param name="log">The log.</param> /// <param name="messageFunc">The message function.</param> /// <param name="activityId">The optional activity ID.</param> /// <remarks> /// This method is intended mostly to enable the efficient use of interpolated C# strings. /// </remarks> public static void LogWarn(this INeonLogger log, Func <string> messageFunc, string activityId = null) { if (log.IsLogWarnEnabled) { log.LogWarn(messageFunc(), activityId); } }
/// <summary> /// Constructor. /// </summary> /// <param name="sourceModule">Optionally enables transient error logging by identifying the source module (defaults to <c>null</c>).</param> public RetryPolicyBase(string sourceModule = null) { if (!string.IsNullOrEmpty(sourceModule)) { log = LogManager.Default.GetLogger(sourceModule); } }
/// <summary> /// <para> /// Upserts the cache entry with an expiration time defined by <see cref="Cache.DurationSeconds"/>. /// After this period, it's no longer possible to reconnect a Blazor session back to the server, /// so we remove the entry from the cache. /// </para> /// </summary> /// <param name="context">The <see cref="HttpContext"/>.</param> /// <param name="cache">The Cache.</param> /// <param name="cipher">The AES Cipher used to encrypt/decrypt cookies.</param> /// <param name="cacheOptions">The Cache options.</param> /// <param name="logger">The <see cref="INeonLogger"/></param> /// <returns></returns> public async Task InvokeAsync( HttpContext context, Service service, IDistributedCache cache, AesCipher cipher, DistributedCacheEntryOptions cacheOptions, INeonLogger logger) { await SyncContext.Clear; await _next(context); if (service.CurrentConnections.Contains(context.Connection.Id)) { var cookie = context.Request.Cookies.Where(c => c.Key == Service.SessionCookieName).First(); var sessionId = cipher.DecryptStringFrom(cookie.Value); var session = NeonHelper.JsonDeserialize <Session>(await cache.GetAsync(sessionId)); if (session.ConnectionId == context.Connection.Id) { await cache.SetAsync(session.Id, NeonHelper.JsonSerializeToBytes(session), cacheOptions); WebsocketMetrics.CurrentConnections.Dec(); service.CurrentConnections.Remove(context.Connection.Id); } } }
private INeonLogger neonLogger; // Non-NULL if [logger] is also an [INeonLogger]. /// <summary> /// Constructor. /// </summary> /// <param name="logger">The <see cref="ILogger"/> being wrapped.</param> public NeonLoggerShim(ILogger logger) { Covenant.Requires <ArgumentNullException>(logger == null, nameof(logger)); this.logger = logger; this.neonLogger = logger as INeonLogger; }
/// <summary> /// Logs a warning exception. /// </summary> /// <param name="log">The log.</param> /// <param name="e">The exception.</param> public static void LogWarn(this INeonLogger log, Exception e) { if (log.IsWarnEnabled) { log.LogWarn(null, e); } }
/// <summary> /// Default constructor. /// </summary> /// <param name="k8s">The <see cref="IKubernetes"/> client used by the controller.</param> /// <param name="options"> /// Optionally specifies options that customize the resource manager's behavior. Reasonable /// defaults will be used when this isn't specified. /// </param> /// <param name="filter"> /// <para> /// Optionally specifies a predicate to be use for filtering the resources to be managed. /// This can be useful for situations where multiple operator instances will partition /// and handle the resources amongst themselves. A good example is a node based operator /// that handles only the resources associated with the node. /// </para> /// <para> /// Your filter should examine the resource passed and return <c>true</c> when the resource /// should be managed by this resource manager. The default filter always returns <c>true</c>. /// </para> /// </param> /// <param name="logger">Optionally specifies the logger to be used by the instance.</param> /// <param name="leaderConfig"> /// Optionally specifies the <see cref="LeaderElectionConfig"/> to be used to control /// whether only a single entity is managing a specific resource kind at a time. See /// the <b>LEADER ELECTION SECTION</b> in the <see cref="ResourceManager{TResource, TController}"/> /// remarks for more information. /// </param> public ResourceManager( IKubernetes k8s, ResourceManagerOptions options = null, Func <TEntity, bool> filter = null, INeonLogger logger = null, LeaderElectionConfig leaderConfig = null) { Covenant.Requires <ArgumentNullException>(k8s != null, nameof(k8s)); this.k8s = k8s; // $todo(jefflill): Can we obtain this from KubeOps or the [IServiceProvider] somehow? this.options = options ?? new ResourceManagerOptions(); this.filter = filter ?? new Func <TEntity, bool>(resource => true); this.log = logger ?? LogManager.Default.GetLogger($"Neon.Kube.Operator.ResourceManager({typeof(TEntity).Name})"); this.leaderConfig = leaderConfig; options.Validate(); // $todo(jefflill): https://github.com/nforgeio/neonKUBE/issues/1589 // // Locate the controller's constructor that has a single [IKubernetes] parameter. var controllerType = typeof(TController); this.controllerConstructor = controllerType.GetConstructor(new Type[] { typeof(IKubernetes) }); if (this.controllerConstructor == null) { throw new NotSupportedException($"Controller type [{controllerType.FullName}] does not have a constructor accepting a single [{nameof(IKubernetes)}] parameter. This is currently required."); } }
/// <summary> /// Constructor. /// </summary> /// <param name="k8s">The Kubernetes clien.</param> /// <param name="logger">Optionally specifies the logger to use.</param> public Watcher(IKubernetes k8s, INeonLogger logger = null) { this.k8s = k8s; this.logger = logger; eventReady = new AsyncAutoResetEvent(); eventQueue = new Queue <WatchEvent <T> >(); }
/// <summary> /// Constructor. /// </summary> /// <param name="log">The inderlying <see cref="INeonLogger"/> implementation.</param> public LogRecorder(INeonLogger log) { Covenant.Requires <ArgumentNullException>(log != null, nameof(log)); this.log = log; this.capture = new StringBuilder(); }
//--------------------------------------------------------------------- // ILog implementation. /// <summary> /// Returns the logger to use for this instance. /// </summary> /// <returns>The logger.</returns> private INeonLogger GetLogger() { // Lazy load the logger for better performance in the common case // where nothing is logged for a request. if (log != null) { return(log); } // $todo(jeff.lill): // // I should be getting either an [ILogProvider] or [ILogManager] dynamically via // dependency injection rather than hardcoding a call to [LogManager.Default] // and then getting an [INeonLogger] from that or wrapping an [ILogger] with // a [NeonLoggerShim]. // // I'm not entirely sure how to accomplish this. I believe the only way is // to add a [ILogProvider] parameter to this class' constructor (as well as // that of any derived classes) and then inspect the actual instance type // passed and then decide whether we need a [NeonLoggerShim] or not. // // It would be unforunate though to require derived classes to have to handle // this. An alternative might be use property injection, but I don't think // the ASP.NET pipeline supports that. // // See the TODO in [LogManager.cs] for more information. return(log = LogManager.Default.GetLogger("Web-" + base.ControllerContext.ActionDescriptor.ControllerName)); }
/// <summary> /// Logs an error exception. /// </summary> /// <param name="log">The log.</param> /// <param name="e">The exception.</param> public static void LogError(this INeonLogger log, Exception e) { if (log.IsErrorEnabled) { log.LogError(null, e); } }
/// <summary> /// Logs a transient exception. /// </summary> /// <param name="log">The log.</param> /// <param name="e">The exception.</param> /// <param name="activityId">The optional activity ID.</param> public static void LogTransient(this INeonLogger log, Exception e, string activityId = null) { if (log.IsLogTransientEnabled) { log.LogTransient(null, e, activityId); } }
/// <summary> /// Constructor. /// </summary> /// <param name="sourceModule">Optionally enables transient error logging by identifying the source module (defaults to <c>null</c>).</param> /// <param name="timeout">Optionally specifies the maximum time the operation should be retried (defaults to no limit).</param> public RetryPolicyBase(string sourceModule = null, TimeSpan?timeout = null) { if (!string.IsNullOrEmpty(sourceModule)) { this.log = LogManager.Default.GetLogger(sourceModule); } if (timeout != null && timeout >= TimeSpan.Zero) { this.Timeout = timeout; // Compute the UTC deadline, taking care not not to // exceed the end-of-time. var utcNow = SysTime.Now; if (timeout >= DateTime.MaxValue - utcNow) { sysDeadline = DateTime.MaxValue; } else { sysDeadline = utcNow + timeout.Value; } } else { sysDeadline = DateTime.MaxValue; } }
/// <summary> /// Logs a critical exception. /// </summary> /// <param name="log">The log.</param> /// <param name="e">The exception.</param> public static void LogCritical(this INeonLogger log, Exception e) { if (log.IsCriticalEnabled) { log.LogCritical(null, e); } }
/// <summary> /// Logs a critical message retrieved via a message function. /// </summary> /// <param name="log">The log.</param> /// <param name="messageFunc">The message function.</param> /// <remarks> /// This method is intended mostly to enable the efficient use of interpolated C# strings. /// </remarks> public static void LogCritical(this INeonLogger log, Func <object> messageFunc) { if (log.IsCriticalEnabled) { log.LogCritical(messageFunc()); } }
/// <summary> /// Constructor. /// </summary> /// <param name="log">Optionally specifies a <see cref="INeonLogger"/> used for logging.</param> /// <param name="gracefulShutdownTimeout">Optionally specifies the termination timeout (defaults to <see cref="GracefulShutdownTimeout"/>).</param> /// <param name="minShutdownTime"> /// Optionally specifies the minimum time to wait before allowing termination to proceed. /// This defaults to the minimum of <paramref name="gracefulShutdownTimeout"/> and <see cref="DefaultMinShutdownTime"/>. /// See the remarks for more details. /// </param> /// <remarks> /// <para> /// <paramref name="gracefulShutdownTimeout"/> defaults to 30 seconds and for environments like Kubernetes, this /// should be set to the same value as the host pod's <b>terminationGracePeriodSeconds</b> when /// that's different from its default value of 30 seconds. /// </para> /// <para> /// <paramref name="minShutdownTime"/> can be used to control the minimum period the service will continue /// to run after receiving a TERM signal. This can be important for ASPNET based services because /// Kubernetes can take something like 10 seconds to remove the pod from the service load balancer /// after sending a TERM to the pod. Having a pod terminate before the load balancer is updated means /// that other pods may see request errors during this time. This blog post goes into this in some /// detail: /// </para> /// <para> /// https://blog.markvincze.com/graceful-termination-in-kubernetes-with-asp-net-core/ /// </para> /// <para> /// <paramref name="minShutdownTime"/> defaults to the minimum of <paramref name="gracefulShutdownTimeout"/> and /// <see cref="GracefulShutdownTimeout"/> to wait for the service load balancer to update. This applies to both /// ASP.NET and headless services so you may wish to reduce <paramref name="minShutdownTime"/> so that headless /// services will terminate quicker. Pass a negative timespan to disable this behavior. /// </para> /// <note> /// The <see cref="Signal"/> method ignores <paramref name="minShutdownTime"/> to improve unit test performance. /// </note> /// </remarks> public ProcessTerminator(INeonLogger log = null, TimeSpan gracefulShutdownTimeout = default, TimeSpan minShutdownTime = default) { Covenant.Requires <ArgumentException>(gracefulShutdownTimeout >= TimeSpan.Zero, nameof(gracefulShutdownTimeout)); Covenant.Requires <ArgumentException>(minShutdownTime >= TimeSpan.Zero, nameof(minShutdownTime)); this.log = log; if (gracefulShutdownTimeout <= TimeSpan.Zero) { gracefulShutdownTimeout = DefaultGracefulTimeout; } if (minShutdownTime == TimeSpan.Zero) { minShutdownTime = DefaultMinShutdownTime; } this.GracefulShutdownTimeout = gracefulShutdownTimeout; this.MinShutdownTime = NeonHelper.Min(gracefulShutdownTimeout, minShutdownTime); this.cts = new CancellationTokenSource(); this.handlers = new List <Action>(); AssemblyLoadContext.Default.Unloading += context => { ExitInternal(); }; }
/// <summary> /// Logs a warning message retrieved via a message function. /// </summary> /// <param name="log">The log.</param> /// <param name="messageFunc">The message function.</param> /// <remarks> /// This method is intended mostly to enable the efficient use of interpolated C# strings. /// </remarks> public static void LogWarn(this INeonLogger log, Func <object> messageFunc) { if (log.IsWarnEnabled) { log.LogWarn(messageFunc()); } }
/// <summary> /// Logs an error message retrieved via a message function. /// </summary> /// <param name="log">The log.</param> /// <param name="messageFunc">The message function.</param> /// <remarks> /// This method is intended mostly to enable the efficient use of interpolated C# strings. /// </remarks> public static void LogError(this INeonLogger log, Func <object> messageFunc) { if (log.IsErrorEnabled) { log.LogError(messageFunc()); } }
/// <summary> /// Logs a debug message retrieved via a message function. /// </summary> /// <param name="log">The log.</param> /// <param name="messageFunc">The message function.</param> /// <remarks> /// This method is intended mostly to enable the efficient use of interpolated C# strings. /// </remarks> public static void LogDebug(this INeonLogger log, Func <object> messageFunc) { if (log.IsDebugEnabled) { log.LogDebug(messageFunc()); } }
/// <summary> /// Logs an informational message retrieved via a message function. /// </summary> /// <param name="log">The log.</param> /// <param name="messageFunc">The message function.</param> /// <remarks> /// This method is intended mostly to enable the efficient use of interpolated C# strings. /// </remarks> public static void LogInfo(this INeonLogger log, Func <object> messageFunc) { if (log.IsInfoEnabled) { log.LogInfo(messageFunc()); } }
/// <summary> /// Logs a critical exception. /// </summary> /// <param name="log">The log.</param> /// <param name="e">The exception.</param> /// <param name="activityId">The optional activity ID.</param> public static void LogCritical(this INeonLogger log, Exception e, string activityId = null) { if (log.IsLogCriticalEnabled) { log.LogCritical(null, e, activityId); } }
/// <summary> /// Formats the log message. /// </summary> /// <param name="neonLogger">The <see cref="INeonLogger"/> implementation or <c>null</c>.</param> /// <param name="message">The message object.</param> /// <param name="activityId">The optional activiity ID.</param> /// <returns>The formatted log event.</returns> private static string FormatMessage(INeonLogger neonLogger, object message, string activityId = null) { string text; if (message == null) { text = string.Empty; } else { text = message.ToString(); } if (!string.IsNullOrEmpty(activityId)) { text += $" [activity-id:{activityId}]"; } if (neonLogger != null && !string.IsNullOrEmpty(neonLogger.ContextId)) { text += $" [context-id:{neonLogger.ContextId}]"; } return(text); }
/// <summary> /// Logs a transient message retrieved via a message function. /// </summary> /// <param name="log">The log.</param> /// <param name="messageFunc">The message function.</param> /// <param name="activityId">The optional activity ID.</param> /// <remarks> /// This method is intended mostly to enable the efficient use of interpolated C# strings. /// </remarks> public static void LogTransient(this INeonLogger log, Func <string> messageFunc, string activityId = null) { if (log.IsLogDebugEnabled) { log.LogTransient(messageFunc(), activityId); } }
/// <summary> /// Logs a debug exception. /// </summary> /// <param name="log">The log.</param> /// <param name="e">The exception.</param> public static void LogDebug(this INeonLogger log, Exception e) { if (log.IsDebugEnabled) { log.LogDebug(null, e); } }
/// <summary> /// Creates a log activity with the ID specified. /// </summary> /// <param name="activityId">The activity ID or <c>null</c>,</param> /// <param name="log">The optional associated <see cref="INeonLogger"/>.</param> /// <returns>The created <see cref="LogActivity"/>.</returns> public static LogActivity From(string activityId, INeonLogger log = null) { return(new LogActivity() { Id = !string.IsNullOrWhiteSpace(activityId) ? activityId : null, log = log }); }
/// <summary> /// Creates a log activity with a new globally unique ID. /// </summary> /// <param name="log">The optional associated <see cref="INeonLogger"/>.</param> /// <returns>The created <see cref="LogActivity"/>.</returns> public static LogActivity Create(INeonLogger log = null) { return(new LogActivity() { Id = Guid.NewGuid().ToString("d"), log = log }); }
public DexClient(Uri baseAddress, INeonLogger logger = null) { this.jsonClient = new JsonClient() { BaseAddress = baseAddress }; this.AuthHeaders = new Dictionary <string, BasicAuthenticationHeaderValue>(); this.Logger = logger; }
/// <summary> /// Constructor. /// </summary> /// <param name="neonDashboardService"></param> /// <param name="neonLogger"></param> /// <param name="cache"></param> public LoginModel( Service neonDashboardService, INeonLogger neonLogger, IDistributedCache cache) { this.neonDashboardService = neonDashboardService; this.logger = neonLogger; this.cache = cache; }
/// <summary> /// Application entry point. /// </summary> /// <param name="args">Command line arguments.</param> public static async Task Main(string[] args) { LogManager.Default.SetLogLevel(Environment.GetEnvironmentVariable("LOG_LEVEL")); log = LogManager.Default.GetLogger(typeof(Program)); log.LogInfo(() => $"Starting [{serviceName}]"); log.LogInfo(() => $"LOG_LEVEL={LogManager.Default.LogLevel.ToString().ToUpper()}"); // Create process terminator to handle termination signals. terminator = new ProcessTerminator(log); try { var commandLine = new CommandLine(args); var command = commandLine.Arguments.ElementAtOrDefault(0); if (command == null) { log.LogError("usage: vegomatic COMMAND ARGS..."); Program.Exit(1, immediate: true); } switch (command) { case "cephfs": await new CephFS().ExecAsync(commandLine.Shift(1)); break; case "issue-mntc": await new IssueMntc().ExecAsync(commandLine.Shift(1)); break; default: case "test-server": await new TestServer().ExecAsync(commandLine.Shift(1)); break; } } catch (Exception e) { log.LogCritical(e); Program.Exit(1); return; } finally { HiveHelper.CloseHive(); terminator.ReadyToExit(); } Program.Exit(0); return; }
/// <summary> /// Constructor. /// </summary> /// <param name="sourceModule">Optionally enables transient error logging by identifying the source module (defaults to <c>null</c>).</param> /// <param name="timeout">Optionally specifies the maximum time the operation will be retried (defaults to unconstrained)</param> public RetryPolicyBase(string sourceModule = null, TimeSpan?timeout = null) { this.SourceModule = sourceModule; this.Timeout = timeout; if (!string.IsNullOrEmpty(sourceModule)) { this.log = LogManager.Default.GetLogger(sourceModule); } }