Esempio n. 1
0
        /// <summary>
        /// Marks the job as cancelled, changing the event written when the job completes.
        /// </summary>
        public void Cancel()
        {
#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
#else
            _Cancelled = true;
#endif
        }
        public RecyclableStringWriter(StringBuilder stringBuilder, IFormatProvider formatProvider) : base(stringBuilder, formatProvider)
        {
            if (stringBuilder == null)
            {
                throw new ArgumentNullException(nameof(stringBuilder));
            }

#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
#else
            _MaxCapacity     = stringBuilder.MaxCapacity;
            _DefaultCapacity = stringBuilder.Capacity;
#endif
        }
Esempio n. 3
0
        /// <summary>
        /// Clears or resets all internal state of this instance so it can be reused.
        /// </summary>
        public void Reset()
        {
#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
#else
            _Logger     = null;
            _JobLogger  = null;
            _JobName    = null;
            _JobId      = null;
            _Exception  = null;
            _Properties = null;
            _Stopwatch.Reset();
#endif
        }
Esempio n. 4
0
        /// <summary>
        /// Returns true if the exception is of a type that indicates a serious system flaw, one that has likely resulted in unknown process state and should not attempt to be handled at all.
        /// </summary>
        /// <param name="exception">The exception to test.</param>
        /// <returns>True if the exception should be rethrown immediately, else false.</returns>
        public static bool ShouldRethrowImmediately(this Exception exception)
        {
#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
            return(false);
#else
            return
                (#if !NETFX_CORE
                 exception is StackOverflowException ||
                 exception is System.Threading.ThreadAbortException ||
                 exception is AccessViolationException ||
#endif
                 exception is OutOfMemoryException);
#endif
        }
Esempio n. 5
0
        public void Initialize(ILogger logger, string jobName, string jobId, IEnumerable <KeyValuePair <string, object> > properties, ILoggedJobPool parentPool, TimeSpan maxExpectedDuration)
        {
            if (logger == null)
            {
                throw new ArgumentNullException(nameof(logger));
            }
            if (jobName == null)
            {
                throw new ArgumentNullException(nameof(jobName));
            }
            if (String.IsNullOrWhiteSpace(jobName))
            {
                throw new ArgumentException(String.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.PropertyCannotBeEmptyOrWhitespace, jobName), nameof(jobName));
            }

            if (String.IsNullOrWhiteSpace(jobId))
            {
                jobId = Guid.NewGuid().ToString();
            }

#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
#else
            _ParentPool          = parentPool;
            _Stopwatch           = new System.Diagnostics.Stopwatch();
            _Logger              = logger;
            _JobId               = jobId ?? Guid.NewGuid().ToString();
            _JobName             = jobName;
            _MaxExpectedDuration = maxExpectedDuration;
            _Properties          = GetExtendedProperties(properties,
                                                         new KeyValuePair <string, object>(Properties.Resources.JobNamePropertyName, jobName),
                                                         new KeyValuePair <string, object>(Properties.Resources.JobIdPropertyName, jobId)
                                                         ).ToArray();

            _Logger.WriteEvent(String.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.JobStartedEventMessage, jobName, jobId),
                               eventSeverity: LogEventSeverity.Information,
                               eventType: LogEventType.Start,
                               properties: _Properties
                               );

            _Stopwatch.Start();
#endif
        }
Esempio n. 6
0
        private static List <System.Reflection.PropertyInfo> GetProperties(Type type)
        {
#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
            return(null);
#else
            List <System.Reflection.PropertyInfo> retVal = null;
            if (!s_PropertyCache.TryGetValue(type, out retVal))
            {
#if !NETFX_CORE
                retVal = new List <System.Reflection.PropertyInfo>(type.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance));
#else
                retVal = new List <System.Reflection.PropertyInfo>(type.GetTypeInfo().DeclaredProperties);
#endif
                s_PropertyCache.TryAdd(type, retVal);
            }

            return(retVal);
#endif
        }
Esempio n. 7
0
        /// <summary>
        /// Creates a new job from the same pool, using the same logger and original properties as well as the new properties provided, and with a "Parent Job ID" property containing the Id of this job for correlation purposes.
        /// </summary>
        /// <param name="jobName">The name or type of the job to create.</param>
        /// <param name="jobId">A unique id of the job used to correlate log entries.</param>
        /// <param name="properties">Null, or a collection key value pairs to associate with the child job.</param>
        /// <returns>A <see cref="LoggedJob"/> instance used to track the job and log related entries.</returns>
        public LoggedJob CreateChildJob(string jobName, string jobId, params KeyValuePair <string, object>[] properties)
        {
#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
            return(null);
#else
            var retVal = _ParentPool?.Take() ?? new LoggedJob();
            IEnumerable <KeyValuePair <string, object> > allProperties = new KeyValuePair <string, object>[] { new KeyValuePair <string, object>(Properties.Resources.ParentJobIdPropertyName, this._JobId) };
            if (properties != null)
            {
                allProperties = allProperties.Union(GetNonJobProperties(properties));
            }
            if (_Properties != null)
            {
                allProperties = allProperties.Union(GetNonJobProperties(_Properties));
            }

            retVal.Initialize(_Logger, jobName, jobId, allProperties, _ParentPool, TimeSpan.Zero);
            return(retVal);
#endif
        }
Esempio n. 8
0
        /// <summary>
        /// Records a failure associated with the job. Will also cause the job completion message to be written with an error severity instead of information.
        /// </summary>
        /// <param name="exception">The exception representing the failure.</param>
        /// <remarks>
        /// <para>If multiple exceptions are recorded, each will be logged individually but the completion message will reference only the first exception.</para>
        /// </remarks>
        /// <exception cref="System.ArgumentNullException">Thrown if <paramref name="exception"/> is null.</exception>
        public void SetFailure(Exception exception)
        {
            if (exception == null)
            {
                throw new ArgumentNullException(nameof(exception));
            }

#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
#else
            if (_Exception == null)
            {
                _Exception = exception;
            }

            _Logger.WriteEventWithSource(String.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.JobFailureEventMessage, _JobName, _JobId, exception.GetType().FullName + ":" + exception.Message),
                                         eventSeverity: LogEventSeverity.Error,
                                         eventType: LogEventType.Failure,
                                         properties: GetExtendedProperties(_Properties, new KeyValuePair <string, object>("Exception", exception)).ToArray()
                                         );
#endif
        }
Esempio n. 9
0
        /// <summary>
        /// Stops timing and writes the job completed event. If a parent pool was supplied, returns the item to the pool.
        /// </summary>
        public void Dispose()
        {
#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
#else
            //If we've been 'reset' and returned to a pool, we don't need to log anything when we're disposed.
            if (_Logger != null)
            {
                var logger = _Logger;
                _Logger = null;

                _Stopwatch.Stop();

                var severity = LogEventSeverity.Information;
                if (_Exception != null)
                {
                    severity = LogEventSeverity.Error;
                }
                else if (_Cancelled || (_Stopwatch.Elapsed > _MaxExpectedDuration && _MaxExpectedDuration != TimeSpan.Zero))
                {
                    severity = LogEventSeverity.Warning;
                }

                logger?.WriteEvent(String.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.JobFinishedEventMessage, _JobName, _JobId),
                                   eventSeverity: severity,
                                   eventType: _Cancelled ? LogEventType.Canceled : LogEventType.Completed,
                                   properties: GetExtendedProperties(
                                       _Properties,
                                       new KeyValuePair <string, object>("Exception", _Exception),
                                       new KeyValuePair <string, object>("Duration", _Stopwatch.Elapsed),
                                       new KeyValuePair <string, object>("Outcome", _Exception != null ? Properties.Resources.FailedOutcome : (_Cancelled ? Properties.Resources.CancelledOutcome : Properties.Resources.CompletedOutcome))
                                       ).ToArray()
                                   );

                _ParentPool?.Add(this);
            }
#endif
        }
Esempio n. 10
0
        /// <summary>
        /// Default constructor.
        /// </summary>
        public LoggedJob()
        {
#if CONTRACTS_ONLY
            BaitExceptionHelper.Throw();
#endif
        }