/// <summary>
    /// Used for player QA events
    /// </summary>
    /// <param name="businessID">
    /// The event identifier. F.x. "FailedToLoadLevel" <see cref="System.String"/>
    /// </param>
    /// <param name="message">
    /// A string detailing the event, F.x. the stack trace from an exception <see cref="System.String"/>
    /// </param>
    /// <param name="stack">
    /// If true any identical messages in the queue will be merged/stacked as a single message, to save server load
    /// </param>
    private void CreateNewEvent(SeverityType severity, string message, float? x, float? y, float? z, bool stack)
    {
        Hashtable parameters = new Hashtable()
        {
            { GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Severity], severity.ToString() },
            { GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Message], message },
            { GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Level], GA.SettingsGA.CustomArea.Equals(string.Empty)?Application.loadedLevelName:GA.SettingsGA.CustomArea }
        };

        if (x.HasValue)
        {
            parameters.Add(GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.X], (x*GA.SettingsGA.HeatmapGridSize.x).ToString());
        }

        if (y.HasValue)
        {
            parameters.Add(GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Y], (y*GA.SettingsGA.HeatmapGridSize.y).ToString());
        }

        if (z.HasValue)
        {
            parameters.Add(GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Z], (z*GA.SettingsGA.HeatmapGridSize.z).ToString());
        }

        GA_Queue.AddItem(parameters, GA_Submit.CategoryType.GA_Error, stack);
    }
Example #2
0
        public void GetExceptionMessage_WithSmartObjectException()
        {
            //Arrange
            var ctor = typeof(SmartObjectExceptionData).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic).FirstOrDefault();

            string             serviceName           = Guid.NewGuid().ToString();
            string             serviceGuid           = Guid.NewGuid().ToString();
            string             message               = Guid.NewGuid().ToString();
            string             innerExceptionMessage = Guid.NewGuid().ToString();
            const SeverityType severity              = SeverityType.Error;

            var smartObjectExceptionData = (SmartObjectExceptionData)ctor.Invoke(new object[] { serviceName, serviceGuid, message, innerExceptionMessage, severity });

            var collection = new SmartObjectExceptionDataCollection
            {
                smartObjectExceptionData
            };
            var    exception = new SmartObjectException(collection);
            string expected  = $@"Service: {serviceName}
Service Guid: {serviceGuid}
Severity: {severity.ToString()}
Error Message: {message}
InnerException Message: {innerExceptionMessage}";

            // Action
            var actual = ExceptionExtensions.GetExceptionMessage(exception);

            // Assert
            Assert.AreEqual(Regex.Replace(expected.Trim(), @"\s+", " "), Regex.Replace(actual.Trim(), @"\s+", " "));
        }
Example #3
0
 /// ****************************************************************
 ///   public WriteIf [static]
 /// ----------------------------------------------------------------
 ///   <summary>
 ///     Writes a message to the debugging logs if the specified
 ///     condition is true.
 ///   </summary>
 /// ----------------------------------------------------------------
 ///   <param name="condition">
 ///		The condition to verify.  If the condition is true, the
 ///		given message is displayed.
 ///   </param>
 ///
 ///   <param name="severity">
 ///     The severity type.
 ///   </param>
 ///
 ///   <param name="category">
 ///     The category type.
 ///   </param>
 ///
 ///   <param name="message">
 ///     The message to log.
 ///   </param>
 /// ****************************************************************
 ///
 public static void WriteIf(bool condition, SeverityType severity, CategoryType category, string message)
 {
     if (true == condition)
     {
         Write(severity, category, message);
     }
 }
Example #4
0
        /// <summary>
        /// Creates a user defined error event
        /// </summary>
        /// <param name="ex"></param>
        /// <param name="properties"></param>
        /// <param name="severity"></param>
        public void Log(Exception ex, Dictionary <string, string> properties = null, SeverityType severity = SeverityType.Error)
        {
            var logEvent = new LogEvent()
            {
                Severity   = severity,
                Summary    = ex.Message,
                Detail     = ex.StackTrace,
                DeviceUID  = _deviceUID,
                UserUID    = _userUID,
                Tag        = ex.GetType().Name,
                Source     = ex.Source,
                Properties = new Dictionary <string, string>()
            };

            foreach (DictionaryEntry p in ex.Data)
            {
                logEvent.Properties.Add(p.Key.ToString(), p.Value.ToString());
            }
            // append additional user data (when provided)
            if (properties != null)
            {
                foreach (var p in properties)
                {
                    logEvent.Properties.Add(p.Key, p.Value);
                }
            }
            log(logEvent);
        }
 private LogMessage(SeverityType severity, string message, Exception exception)
 {
     Severity = severity;
     Message = message;
     Exception = exception;
     Stamp = DateTime.Now;
 }
Example #6
0
    /// <summary>
    /// Used for player QA events
    /// </summary>
    /// <param name="businessID">
    /// The event identifier. F.x. "FailedToLoadLevel" <see cref="System.String"/>
    /// </param>
    /// <param name="message">
    /// A string detailing the event, F.x. the stack trace from an exception <see cref="System.String"/>
    /// </param>
    /// <param name="stack">
    /// If true any identical messages in the queue will be merged/stacked as a single message, to save server load
    /// </param>
    private void CreateNewEvent(SeverityType severity, string message, float?x, float?y, float?z, bool stack)
    {
        Hashtable parameters = new Hashtable()
        {
            { GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Severity], severity.ToString() },
            { GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Message], message },
            { GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Level], GA.SettingsGA.CustomArea.Equals(string.Empty)?Application.loadedLevelName:GA.SettingsGA.CustomArea }
        };

        if (x.HasValue)
        {
            parameters.Add(GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.X], (x * GA.SettingsGA.HeatmapGridSize.x).ToString());
        }

        if (y.HasValue)
        {
            parameters.Add(GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Y], (y * GA.SettingsGA.HeatmapGridSize.y).ToString());
        }

        if (z.HasValue)
        {
            parameters.Add(GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Z], (z * GA.SettingsGA.HeatmapGridSize.z).ToString());
        }

        GA_Queue.AddItem(parameters, GA_Submit.CategoryType.GA_Error, stack);
    }
Example #7
0
        /// ****************************************************************
        ///   public WriteDebugger [static]
        /// ----------------------------------------------------------------
        ///   <summary>
        ///     Writes a message to the debugger.
        ///   </summary>
        /// ----------------------------------------------------------------
        ///   <param name="severity">
        ///     The severity type.
        ///   </param>
        ///
        ///   <param name="category">
        ///     The category type.
        ///   </param>
        ///
        ///   <param name="message">
        ///     The message.
        ///   </param>
        /// ****************************************************************
        ///
        public static void WriteDebugger(SeverityType severity, CategoryType category, string message)
        {
            try
            {
                string text = string.Format(
                    "{0,-4}  {1,-4}  {2}",
                    severity.ToString().Substring(0, 4).ToUpper(),
                    category.ToString().Substring(0, 4).ToUpper(),
                    message.Replace("\r\n", "\r\n\t\t"));

                //
                // Write out the debugger message.
                //
                System.Diagnostics.Trace.WriteLine(text);
            }
            catch (Exception)
            {
                //
                // WriteDebugger is used as a last ditch logging mechanism
                // in many cases.  This should never throw an exception,
                // but if it does, there really isn't any more we can do
                // about it.  We'll simply eat the error.
                //
            }
        }
Example #8
0
        /// <summary>
        /// Used  to Log any data or exceptions that occured during running the program.
        /// </summary>
        /// <param name="Msg">the user friendly massage or any informations</param>
        /// <param name="category">Mean the project who have the problem or who want to write a message</param>
        /// <param name="priority">mean the important of the logging ex.High or Low</param>
        /// <param name="Type">the Type of the message ex.Error or info.</param>
        /// <param name="Properties">any addition informations</param>
        public static void Log(string Msg, Category category, Priority priority, SeverityType Type, IDictionary <string, object> Properties)
        {
            #region Filling Extra properties

            Logger.Log(Msg, category, priority, Type, Properties);
            #endregion
        }
Example #9
0
 public LogMessage(SeverityType severity, string message, Exception exception)
 {
     Severity  = severity;
     Message   = message;
     Exception = exception;
     Stamp     = DateTime.Now;
 }
Example #10
0
 public Response(IDictionary <SeverityType, IEnumerable <string> > reports, SeverityType severity)
 {
     this.Reports     = reports;
     this.Severity    = severity;
     this.Id          = Guid.NewGuid();
     this.LastUpdated = DateTime.UtcNow;
 }
        public void LogToServerTest()
        {
            Microsoft.Practices.EnterpriseLibrary.Logging.Logger.Writer.Write("Hello");

            #region Loading Variables

            //ServerLoggingHandler target = new ServerLoggingHandler(); // TODO: Initialize to an appropriate value
            string Msg = "Hello Logging Server Side ";

            Category     category = Category.ServerData;
            Priority     priority = Priority.Highest;
            SeverityType Type     = SeverityType.Information;
            IDictionary <string, object> Properties = new Dictionary <string, object>();
            Properties.Add("TestKey", "test value");
            #endregion

            #region Acual Test


            LoggingProvider <ServerLoggingHandler> .Log(Msg, category);

            LoggingProvider <ServerLoggingHandler> .Log(Msg, category, priority);

            LoggingProvider <ServerLoggingHandler> .Log(Msg, category, priority, Type);

            LoggingProvider <ServerLoggingHandler> .Log(Msg, category, Properties);

            LoggingProvider <ServerLoggingHandler> .Log(Msg, category, priority, Type, Properties);

            #endregion
        }
Example #12
0
        /// <summary>
        /// Create DiagnosticHelper instance based on Microsoft.CodeAnalysis.<see cref="Diagnostic"/> class.
        /// </summary>
        /// <param name="diagnostic">Diagnostic info, which is use to create helper object</param>
        /// <returns>Helper object based on <see cref="diagnostic"/></returns>
        public static DiagnosticHelper Create(Diagnostic diagnostic)
        {
            // Set proper severity type
            SeverityType severity = SeverityType.None;

            if (diagnostic.Severity == DiagnosticSeverity.Error)
            {
                severity = SeverityType.Error;
            }
            else if (diagnostic.Severity == DiagnosticSeverity.Warning)
            {
                severity = SeverityType.Warning;
            }
            else if (diagnostic.Severity == DiagnosticSeverity.Info)
            {
                severity = SeverityType.Info;
            }

            // Create helper object
            return(new DiagnosticHelper {
                Severity = severity,
                Location = new CodeLocation(diagnostic.Location),
                Information = diagnostic.GetMessage(),
                SyntaxNode = diagnostic.Location
                             .SourceTree
                             ?.GetRoot()
                             .FindNode(diagnostic.Location.SourceSpan),
            });
        }
Example #13
0
        private void PrepareLogMessageAndRaise(string body, LevelType level, SeverityType severity, params object[] parameters)
        {
            string text = "";

            try
            {
                text = parameters.Length == 0 ? body : string.Format(body, parameters);
            }
            catch
            {
                text = body;
            }

            Event msg = NewEvent();

            msg.Lg = new Log()
            {
                Format   = FormatType.Plain,
                Body     = text,
                Level    = level,
                Severity = severity
            };

            OnNewMessage(msg);
        }
Example #14
0
        /// ****************************************************************
        ///   public Write [static]
        /// ----------------------------------------------------------------
        ///   <summary>
        ///     Writes a message to the debugging logs.
        ///   </summary>
        /// ----------------------------------------------------------------
        ///   <param name="severity">
        ///     The Severity type.
        ///   </param>
        ///
        ///   <param name="category">
        ///     The category type.
        ///   </param>
        ///
        ///   <param name="message">
        ///     The message to log.
        ///   </param>
        /// ----------------------------------------------------------------
        ///   <remarks>
        ///     Debugging information is logged to the debugger, log file,
        ///     and event log depending on the level of the following
        ///     configuration settings:
        ///
        ///			Debug.DebuggerLevel
        ///			Debug.EventLogLevel
        ///			Debug.FileLogLevel
        ///
        ///		Where the trace level is the highest severity to log:
        ///			0 = none
        ///			1 = errors
        ///			2 = warnings
        ///			3 = failure audit messages
        ///			4 = success audit messages
        ///			5 = information messages
        ///			6 = all (verbose)
        ///   </remarks>
        /// ****************************************************************
        ///
        public static void Write(SeverityType severity, CategoryType category, string message)
        {
            //
            // Write to the debugger if the level setting is high enough.
            //
            if ((int)severity <= debuggerLevel.GetInt())
            {
                WriteDebugger(severity, category, message);
            }

            //
            // Write to the event log if the level setting is high enough.
            //
            if ((int)severity <= eventLogLevel.GetInt())
            {
                WriteEventLog(severity, category, OperatorMessageType.None, message);
            }

            //
            // Write to the file log if the level setting is high enough.
            //
            if ((int)severity <= fileLogLevel.GetInt())
            {
                WriteFileLog(severity, category, message);
            }
        }
        public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
        {
            SeverityType severity = SeverityType.Debug;

            if (IsEnabled(logLevel))
            {
                switch (logLevel)
                {
                case LogLevel.Information:
                    severity = SeverityType.Informational;
                    break;

                case LogLevel.Warning:
                    severity = SeverityType.Warning;
                    break;

                case LogLevel.Error:
                    severity = SeverityType.Error;
                    break;

                case LogLevel.Critical:
                    severity = SeverityType.Critical;
                    break;
                }
            }
            else
            {
                return;
            }

            if (formatter == null)
            {
                throw new ArgumentNullException(nameof(formatter));
            }

            string message = formatter(state, exception);

            if (!String.IsNullOrEmpty(message))
            {
                int    priority = ((int)FacilityType.Local0 * 8) + (int)severity;                                                           // (Facility * 8) + Severity = Priority
                string msg      = String.Format("<{0}>{1:MMM dd HH:mm:ss} {2} {3}", priority, DateTime.Now, _host, _name + ": " + message); // RFC 3164 header format

                UdpClient udp = new UdpClient();
                byte[]    raw = Encoding.ASCII.GetBytes(msg);

                try
                {
                    udp.SendAsync(raw, Math.Min(raw.Length, 1024), _settings.ServerHost, _settings.ServerPort);
                }
                finally
                {
#if NET452
                    udp.Close();
#else
                    udp.Dispose();
#endif
                }
            }
        }
Example #16
0
 public Bug(string id, string title, PriorityType priority, SeverityType severity, IList <string> steps, string description)
     : base(id, title, description)
 {
     this.priorityType = priority;
     this.severityType = severity;
     this.bugStatus    = BugStatus.Active;
     this.steps        = steps;
 }
Example #17
0
 public ValidationMessage(string message, SeverityType severity, int lineNumber, int linePosition, Exception exception)
 {
     Message      = message;
     Severity     = severity;
     LineNumber   = lineNumber;
     LinePosition = linePosition;
     Exception    = exception;
 }
 public LogEntry(string _caption, SeverityType _severity, bool _isLogOnly, string _message)
 {
     Caption   = _caption;
     Message   = _message;
     Severity  = _severity;
     Timestamp = DateTime.Now;
     IsLogOnly = _isLogOnly;
 }
Example #19
0
 public ValidationMessage(string message, SeverityType severity, int lineNumber, int linePosition, Exception exception)
 {
     Message = message;
     Severity = severity;
     LineNumber = lineNumber;
     LinePosition = linePosition;
     Exception = exception;
 }
Example #20
0
 public ResultCode(SeverityType severity, bool custom, int facility, int code)
 {
     ID       = 0;
     Severity = severity;
     Custom   = custom;
     Facility = facility;
     Code     = code;
 }
Example #21
0
        //
        // Note: All calls to this function should occur in administrator initiated
        // processes. No calls to this function should as a result of an HTTP request from
        // a SOAP API.
        // This is verified to be true on 3/1/2002 by creeves
        //
        public static void OperatorMail(SeverityType severity, CategoryType category, OperatorMessageType messageId, string message)
        {
            string mailTo = Config.GetString("Debug.MailTo", null);

            if (null == mailTo)
            {
                Debug.Write(
                    SeverityType.Info,
                    CategoryType.Config,
                    "Skipping send of operator mail.  Configuration setting 'Debug.MailTo' not set.");

                return;
            }

            Debug.VerifySetting("Debug.MailFrom");

            try
            {
                string mailCc      = Config.GetString("Debug.MailCc", null);
                string mailSubject = Config.GetString(
                    "Debug.MailSubject",
                    "Operator message from {0}.  Severity: {1}, Category: {2}");

                MailMessage mail = new MailMessage();

                mail.To      = mailTo;
                mail.From    = Config.GetString("Debug.MailFrom");
                mail.Subject = String.Format(
                    mailSubject,
                    System.Environment.MachineName,
                    severity.ToString(),
                    category.ToString(),
                    (int)messageId);

                if (null != mailCc)
                {
                    mail.Cc = mailCc;
                }

                mail.BodyFormat = MailFormat.Text;
                mail.Body       =
                    "SEVERITY: " + severity.ToString() + "\r\n" +
                    "CATEGORY: " + category.ToString() + "\r\n" +
                    "EVENT ID: " + (int)messageId + "\r\n\r\n" +
                    message;

                SmtpMail.Send(mail);
            }
            catch (Exception e)
            {
                Debug.OperatorMessage(
                    SeverityType.Error,
                    CategoryType.None,
                    OperatorMessageType.CouldNotSendMail,
                    "Could not send operator mail.\r\n\r\nDetails:\r\n\r\n" + e.ToString());
            }
        }
Example #22
0
 public static void WriteError(object errorMessage, SeverityType severity, string errorCategory, IDictionary <string, object> properties)
 {
     //var worker = new BackgroundWorker();
     //worker.DoWork += delegate(object sender, DoWorkEventArgs e)
     //{
     Writer.WriteError(errorMessage, severity, errorCategory, properties);
     //};
     //worker.RunWorkerAsync();
 }
Example #23
0
        /// ****************************************************************
        ///   public WriteEventLog [static]
        /// ----------------------------------------------------------------
        ///   <summary>
        ///     Writes a message to the event log.
        ///   </summary>
        /// ----------------------------------------------------------------
        ///   <param name="severity">
        ///     The severity type.
        ///   </param>
        ///
        ///   <param name="category">
        ///     The category type.
        ///   </param>
        ///
        ///   <param name="messageId">
        ///	    The message type.
        ///   </param>
        ///
        ///   <param name="message">
        ///     The message.
        ///   </param>
        /// ****************************************************************
        ///
        public static void WriteEventLog(SeverityType severity, CategoryType category, OperatorMessageType messageId, string message)
        {
            readWriteLock.AcquireReaderLock(Constants.ReadLockTimeout);

            try
            {
                //
                // Map the severity type to an event log entry type.
                //
                System.Diagnostics.EventLogEntryType entryType;

                switch (severity)
                {
                case SeverityType.Error:
                    entryType = System.Diagnostics.EventLogEntryType.Error;
                    break;

                case SeverityType.Warning:
                    entryType = System.Diagnostics.EventLogEntryType.Warning;
                    break;

                case SeverityType.PassAudit:
                    entryType = System.Diagnostics.EventLogEntryType.SuccessAudit;
                    break;

                case SeverityType.FailAudit:
                    entryType = System.Diagnostics.EventLogEntryType.FailureAudit;
                    break;

                default:
                    //
                    // SeverityType.Info and Verbose are mapped to info
                    //
                    entryType = System.Diagnostics.EventLogEntryType.Information;
                    break;
                }

                System.Diagnostics.EventLog.WriteEntry(
                    "UDDIRuntime",
                    message,
                    entryType,
                    (int)messageId,
                    (short)category);
            }
            catch (Exception e)
            {
                WriteDebugger(
                    SeverityType.Error,
                    CategoryType.None,
                    "Could not write to event log.\r\n\r\nDetails:\r\n" + e.ToString());
            }
            finally
            {
                readWriteLock.ReleaseReaderLock();
            }
        }
 public LogEntry(Exception _exception, string _caption, SeverityType _severity, bool _isLogOnly, string _message)
 {
     IsException = true;
     Exception   = _exception;
     Caption     = _caption;
     Message     = _message;
     Severity    = _severity;
     Timestamp   = DateTime.Now;
     IsLogOnly   = _isLogOnly;
 }
Example #25
0
        private void WriteError(object errorMessage, SeverityType severity, string errorCategory, IDictionary <string, object> properties)
        {
            var props = EnsureProperties(properties);

            props.Add(XFConstants.EventWriter.Message, errorMessage.ToString());
            props.Add(XFConstants.EventWriter.ErrorSeverity, severity.ToString());
            props.Add(XFConstants.EventWriter.Category, errorCategory);
            props.Add(XFConstants.EventWriter.EventType, EventTypeOption.Error);
            LocalPublish(EventTypeOption.Error, props);
        }
Example #26
0
        //public Bug(string title) : base(title)
        //{
        //    base.Тype = WorkItemType.Bug;
        //}

        public Bug(string title, string description = "description", List <string> steps       = null,
                   PriorityType priority            = PriorityType.None, SeverityType severity = SeverityType.None, BugStatus bugStatus = BugStatus.None, Person assignee = null, List <IComment> comments = null, List <Activity> history = null) :
            base(title, description, assignee, comments, history)
        {
            base.Тype      = WorkItemType.Bug;
            this.Steps     = steps;
            this.Priority  = priority;
            this.Severity  = severity;
            this.BugStatus = bugStatus;
        }
Example #27
0
        public static void SendMessage(string messageToSend, string sectionToSend, SeverityType severityTypeToSend)
        {
            var resultSentMessage = false;

            ContainerAccessPoint.Container.Resolve <IEventAggregator>().GetEvent <AlertEvent>().Publish(new Alert
            {
                Section  = sectionToSend,
                Severity = severityTypeToSend,
                Id       = messageToSend
            });
        }
Example #28
0
        private void dgvMain_RowPostPaint(object sender, DataGridViewRowPostPaintEventArgs e)
        {
            SeverityType x = (SeverityType)Enum.Parse(typeof(SeverityType), this.dataGridView1[1, e.RowIndex].Value.ToString());

            if ((int)x < 5)


            {
                this.dataGridView1.Rows[e.RowIndex].DefaultCellStyle.BackColor = Color.FromArgb(0xe0, 0x00, 0x00);
            }
        }
Example #29
0
    /// <summary>
    /// Used for player QA events
    /// </summary>
    /// <param name="businessID">
    /// The event identifier. F.x. "FailedToLoadLevel" <see cref="System.String"/>
    /// </param>
    /// <param name="message">
    /// A string detailing the event, F.x. the stack trace from an exception <see cref="System.String"/>
    /// </param>
    /// <param name="stack">
    /// If true any identical messages in the queue will be merged/stacked as a single message, to save server load
    /// </param>
    private void CreateNewEvent(SeverityType severity, string message, bool stack)
    {
        Hashtable parameters = new Hashtable()
        {
            { GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Severity], severity.ToString() },
            { GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Message], message },
            { GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Level], GA.SettingsGA.CustomArea.Equals(string.Empty)?Application.loadedLevelName:GA.SettingsGA.CustomArea }
        };

        GA_Queue.AddItem(parameters, GA_Submit.CategoryType.GA_Error, stack);
    }
Example #30
0
	/// <summary>
	/// Used for player QA events
	/// </summary>
	/// <param name="businessID">
	/// The event identifier. F.x. "FailedToLoadLevel" <see cref="System.String"/>
	/// </param>
	/// <param name="message">
	/// A string detailing the event, F.x. the stack trace from an exception <see cref="System.String"/>
	/// </param>
	/// <param name="stack">
	/// If true any identical messages in the queue will be merged/stacked as a single message, to save server load
	/// </param>
	private  void CreateNewEvent(SeverityType severity, string message, bool stack)
	{
		Hashtable parameters = new Hashtable()
		{
			{ GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Severity], severity.ToString() },
			{ GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Message], message },
			{ GA_ServerFieldTypes.Fields[GA_ServerFieldTypes.FieldType.Level], GA.SettingsGA.CustomArea.Equals(string.Empty)?Application.loadedLevelName:GA.SettingsGA.CustomArea }
		};
		
		GA_Queue.AddItem(parameters, GA_Submit.CategoryType.GA_Error, stack);
	}
Example #31
0
 public void SetMessage(SeverityType severityType, string message = null)
 {
     lock (messageLock)
     {
         if (severityType == SeverityType.None || string.IsNullOrEmpty(message))
         {
             Message = string.Empty;
         }
         else
         {
             Message = string.Format("{0}: {1}", severityType, message);
         }
     }
 }
Example #32
0
        internal CanValidateOwnerCheck(CalendarValidationContext context)
        {
            SeverityType severity = SeverityType.FatalError;

            if (context.BaseItem == null || context.BaseItem.IsCancelled)
            {
                severity = SeverityType.Information;
            }
            else if (context.BaseRole == RoleType.Organizer && (context.Attendee.ResponseType == ResponseType.NotResponded || context.Attendee.ResponseType == ResponseType.None))
            {
                severity = SeverityType.Warning;
            }
            this.Initialize(ConsistencyCheckType.CanValidateOwnerCheck, "Checks whether the counterpart user can be validated or not.", severity, context, null);
        }
Example #33
0
        protected virtual void LogToConsole(string body, LevelType level, SeverityType severity, params object[] parameters)
        {
            string text = "";

            try
            {
                text = parameters.Length == 0 ? body : string.Format(body, parameters);
            }
            catch
            {
                text = body;
            }

            Console.WriteLine($"{DateTime.Now.ToString("HH:mm")} {level.ToString()} {severity.ToString()} | {text}");
        }
 public AnalysisResult(
     string findingMessage,
     SeverityType severity,
     string recommendation,
     string testType,
     IEnumerable <KeyValuePair <string, string> > additionalProps,
     IEnumerable <string> referenceUrl)
 {
     this.FindingMessage       = findingMessage;
     this.Recommendation       = recommendation;
     this.Severity             = severity;
     this.AdditionalProperties = additionalProps;
     this.TestType             = testType;
     this.ReferenceUrl         = referenceUrl;
 }
Example #35
0
 public void NewEvent(SeverityType severity, string message, float x, float y, float z)
 {
     CreateNewEvent(severity, message, x, y, z, false);
 }
Example #36
0
 public void NewEvent(SeverityType severity, string message, Vector3 trackPosition)
 {
     CreateNewEvent(severity, message, trackPosition.x, trackPosition.y, trackPosition.z, false);
 }
Example #37
0
 public ValidationMessage(string message, SeverityType severity, int lineNumber, int linePosition)
     : this(message, severity, lineNumber, linePosition, null)
 { }
 public AppException(string message, SeverityType severity)
     : base(message, severity)
 {
 }
 public static void Log(SeverityType severity, string message, Exception exception, IEventManager eventmanager)
 {
     eventmanager.Publish(new LogMessage(severity, message, exception));
 }
 public static void Log(SeverityType severity, string message, IEventManager eventmanager)
 {
     Log(severity, message, null, eventmanager);
 }
Example #41
0
 public void NewEvent(SeverityType severity, string message)
 {
     CreateNewEvent(severity, message, null, null, null, false);
 }
Example #42
0
 public ValidationError(string errorMessage, object targetInstance, string propertyName, string validationType, SeverityType severityType)
     : this(errorMessage, targetInstance, propertyName)
 {
     this.ValidationType = validationType;
     this.SeverityType = severityType;
 }
 public AppException(int errorCode, string message, SeverityType severity, Exception inner)
     : base(errorCode, message, severity, inner)
 {
 }
Example #44
0
	public void NewErrorEvent(SeverityType severity, string message)
	{
		CreateNewEvent(severity, message, true);
	}