示例#1
0
        /// <summary>
        /// Handles the specified ex.
        /// </summary>
        /// <param name="ex">The ex.</param>
        /// <param name="additionalInfo">The additional information.</param>
        /// <param name="ignoreTracking">if set to <c>true</c> [ignore tracking].</param>
        public void Handle(Exception ex, NameValueCollection additionalInfo = null, bool ignoreTracking = false)
        {
            if (!TimeEventTracker.CanEvent(ex.Message, _eventTracking, out int occurrences) || ignoreTracking)
            {
                return;
            }

            additionalInfo = additionalInfo ?? new NameValueCollection();
            additionalInfo["TrackingId"] = SequentialGuid.NewGuid().ToString();
            additionalInfo["Time (UTC)"] = DateTime.UtcNow.ToString();

            if (occurrences != 0)
            {
                additionalInfo["Occurrences"] = occurrences.ToString("N0");
            }

            foreach (var handler in _exceptionHandlers)
            {
                try
                {
                    handler.Handle(ex, additionalInfo);
                }
                catch (Exception ex2)
                {
                    // one of the handlers screwed up.

                    var error            = $"Exception Handler: '{handler.Name}' threw an unhandled exception.";
                    var handlerException = new AggregateException(new Exception(error, ex2), ex);

                    var errorMessage = ExceptionFormatter.ConstructMessage(handlerException, additionalInfo);
                    _logger.LogError(errorMessage);
                }
            }
        }
示例#2
0
        /// <summary>
        /// Publishes the specified ex.
        /// </summary>
        /// <param name="ex">The ex.</param>
        /// <param name="additionalParameters">The additional parameters.</param>
        static public void Publish(Exception ex, NameValueCollection additionalParameters)
        {
            try
            {
                // add time stamps
                var now = DateTime.UtcNow;
                additionalParameters = additionalParameters ?? new NameValueCollection();
                additionalParameters.Add("Local Time", now.ToString("yyyy/MM/dd, HH:mm:ss.fff"));
                additionalParameters.Add("UTC", now.ToUniversalTime().ToString("yyyy/MM/dd, HH:mm:ss.fff"));

                if (!TimeEventTracker.CanEvent(ex.Message, _eventTracking, out int occurrences))
                {
                    return;
                }


                additionalParameters = additionalParameters ?? new NameValueCollection();

                if (occurrences != 0)
                {
                    additionalParameters = additionalParameters ?? new NameValueCollection();
                    additionalParameters["Occurrences"] = occurrences.ToString("N0");
                }

                var message = ExceptionFormatter.ConstructMessage(ex, additionalParameters);
                _logTextFileWriter.WriteLine(message);
            }
            catch (Exception)
            {
                // nothing we can do just swallow
            }
        }
        /// <summary>
        /// Sends the exception.
        /// </summary>
        /// <param name="ex">The ex.</param>
        /// <param name="bIgnoreTracker">if set to <c>true</c> [b ignore tracker].</param>
        public override void SendException(Exception ex, bool bIgnoreTracker = false)
        {
            var eventTracker = new TimeSpan(0, WorkManagerConfig.EventTracker, 0);

            if (bIgnoreTracker || TimeEventTracker.CanEvent((int)StringHash.BKDRHash(ex.Message), eventTracker))
            {
                // add additional information to the Exception Info.
                var additionalInfo = new NameValueCollection();
                additionalInfo.Add("Timestamp", DateTimeOffset.Now.ToString());
                additionalInfo.Add("Application Source", WorkManagerConfig.ApplicationName);

                ExceptionManagerContainer.Publish(ex, additionalInfo);
            }
        }
示例#4
0
 protected void DoOnException(Exception ex)
 {
     if (!UseLogExceptionTimeSpan || TimeEventTracker.CanEvent((Int32)ex.Message.BKDRHash(), LogExceptionTimeSpan))
     {
         try
         {
             if (OnException != null)
             {
                 OnException(ex);
             }
             else
             {
                 LogError(ex.StackTrace);
             }
         }
         catch (Exception ex2)
         {
             LogError(ex2.StackTrace);
         }
     }
 }
示例#5
0
 /// <summary>
 /// Determines whether this instance can event the specified ex.
 /// </summary>
 /// <param name="ex">The ex.</param>
 /// <returns>
 ///   <c>true</c> if this instance can event the specified ex; otherwise, <c>false</c>.
 /// </returns>
 static public bool CanEvent(Exception ex)
 {
     return(TimeEventTracker.CanEvent((int)ex.Message.BKDRHash(), _eventTracking));
 }
示例#6
0
        /// <summary>
        /// Publishes the specified ex.
        /// </summary>
        /// <param name="ex">The ex.</param>
        /// <param name="additionalParameters">The additional parameters.</param>
        public void Publish(Exception ex, NameValueCollection additionalParameters)
        {
            int occurrences;

            if (!TimeEventTracker.CanEvent(ex.Message, _eventTracking, out occurrences))
            {
                return;
            }

            additionalParameters = additionalParameters ?? new NameValueCollection();

            if (occurrences != 0)
            {
                additionalParameters = additionalParameters ?? new NameValueCollection();
                additionalParameters["Occurrences"] = occurrences.ToString("N0");
            }

            lock (_publishers)
            {
                try
                {
                    try
                    {
                        _unhandledExceptions.Clear();
                        _unhandledExceptions.Capacity = 0;

                        foreach (PublisherInfo publisher in _publishers.ToArray())
                        {
                            try
                            {
                                publisher.Publisher.Publish(ex, additionalParameters);
                            }
                            catch (Exception unhandledEx)
                            {
                                MiscHelper.DisposeObject(publisher);
                                _publishers.Remove(publisher);

                                var unEx = new UnhandledExceptionInfo()
                                {
                                    PublisherAttributes = publisher.PublisherAttributes,
                                    Exception           = unhandledEx
                                };

                                _unhandledExceptions.Add(unEx);
                            }
                        }

                        foreach (UnhandledExceptionInfo eInfo in _unhandledExceptions)
                        {
                            var eMsg       = string.Format("The following Publisher: '{0}' caused an Unhandled exception", eInfo.PublisherAttributes.Attributes["name"]);
                            var internalEx = new Exception(eMsg, eInfo.Exception);

                            var exMessage = ExceptionFormatter.ConstructMessage(internalEx);
                            MiscHelper.WriteToEventLog(_eventLogSource, exMessage, EventLogEntryType.Error);
                        }
                    }
                    catch (Exception excep)
                    {
                        var exMessage = ExceptionFormatter.ConstructMessage(excep);
                        MiscHelper.WriteToEventLog(_eventLogSource, exMessage, EventLogEntryType.Error);
                    }
                }
                catch (Exception)
                {
                    // not much we can do here.
                }
            }
        }