public void CustomerIdIsNotExtractedFromCustomerLogDataIfDataIsNull()
        {
            var result = CustomerLogData.TryExtractCustomerId(null, out Guid? customerId);

            Assert.IsNull(result);
            Assert.IsNull(customerId);
        }
        public void CustomerIdIsNotExtractedFromCustomerLogDataIfObjectIsNotCustomerLogData()
        {
            object data   = new { Value = "Just a test" };
            var    result = CustomerLogData.TryExtractCustomerId(data, out Guid? customerId);

            Assert.AreEqual(data, result);
            Assert.IsNull(customerId);
        }
        public void ObjectIsNotWrappedIfSourceIsNull()
        {
            object data   = new { Value = "Unit test Data" };
            var    result = CustomerLogData.TryParseFromData(null, data, out CustomerLogData customerLogData);

            Assert.IsFalse(result);
            Assert.IsNull(customerLogData);
        }
        public void StringIsNotWrappedIfSourceIsNull()
        {
            string data   = "Unit Test String";
            var    result = CustomerLogData.TryParseFromMessage(null, data, out CustomerLogData customerLogData);

            Assert.IsFalse(result);
            Assert.IsNull(customerLogData);
        }
        public void ObjectIsNotWrappedIfNoCustomerIdIsFound()
        {
            object      data        = new { Value = "Unit test Data" };
            TraceSource traceSource = new TraceSource("Test");
            var         result      = CustomerLogData.TryParseFromData(traceSource, data, out CustomerLogData customerLogData);

            Assert.IsFalse(result);
            Assert.IsNull(customerLogData);
        }
        public void StringIsNotWrappedIfNoCustomerIdIsFound()
        {
            string      data        = "Unit Test String";
            TraceSource traceSource = new TraceSource("Test");
            var         result      = CustomerLogData.TryParseFromMessage(traceSource, data, out CustomerLogData customerLogData);

            Assert.IsFalse(result);
            Assert.IsNull(customerLogData);
        }
        public void ObjectIsNotWrappedIfCustomerIdIsNull()
        {
            object data = new { Value = "Unit test Data" };

            System.Diagnostics.TraceSource traceSource = new TraceSource("Test");
            traceSource.Attributes["customerid"] = null;
            var result = CustomerLogData.TryParseFromData(traceSource, data, out CustomerLogData customerLogData);

            Assert.IsFalse(result);
            Assert.IsNull(customerLogData);
        }
        public void CustomerIdIsExtractedFromCustomerLogDataIfDataIsNull()
        {
            CustomerLogData data = new CustomerLogData();

            data.CustomerId = new Guid("c9f920f7-8060-492c-ba4b-6bce916d6255");
            data.Data       = null;
            var result = CustomerLogData.TryExtractCustomerId(data, out Guid? customerId);

            Assert.AreEqual(data.CustomerId, customerId);
            Assert.AreEqual(data.Data, result);
        }
        public void CustomerIdGetsExtractedFromCustomerLogDataWithObject()
        {
            CustomerLogData data = new CustomerLogData();

            data.CustomerId = new Guid("c9f920f7-8060-492c-ba4b-6bce916d6255");
            data.Data       = new { Value = "Unit Test Data" };
            var result = CustomerLogData.TryExtractCustomerId(data, out Guid? customerId);

            Assert.AreEqual(data.CustomerId, customerId);
            Assert.AreEqual(data.Data, result);
        }
        public void CustomerIdGetsExtractedFromCustomerLogDataWithMessage()
        {
            CustomerLogData data = new CustomerLogData();

            data.CustomerId = new Guid("c9f920f7-8060-492c-ba4b-6bce916d6255");
            data.Data       = "Test Message";
            var result = CustomerLogData.TryExtractCustomerId(data, out Guid? customerId);

            Assert.AreEqual(data.CustomerId, customerId);
            Assert.AreEqual(data.Data, result);
        }
        public void StringIsNotWrappedIfCustomerIdIsNull()
        {
            string data = "Unit Test String";

            System.Diagnostics.TraceSource traceSource = new TraceSource("Test");
            traceSource.Attributes["customerid"] = null;
            var result = CustomerLogData.TryParseFromMessage(traceSource, data, out CustomerLogData customerLogData);

            Assert.IsFalse(result);
            Assert.IsNull(customerLogData);
        }
        public void CustomerIdIsNotExtractedFromCustomerLogDataIfCustomerIdIsNull()
        {
            CustomerLogData data = new CustomerLogData();

            data.CustomerId = null;
            data.Data       = new { Value = "Unit Test Data" };
            var result = CustomerLogData.TryExtractCustomerId(data, out Guid? customerId);

            Assert.IsNull(customerId);
            Assert.AreEqual(data.Data, result);
        }
        public void CustomerLogDataIsNotWrappedInsideCustomerLogData()
        {
            CustomerLogData data = new CustomerLogData();

            data.CustomerId = new Guid();
            TraceSource traceSource = new TraceSource("Test");

            traceSource.Attributes["customerid"] = data.CustomerId.ToString();
            var result = CustomerLogData.TryParseFromData(traceSource, data, out CustomerLogData customerLogData);

            Assert.IsFalse(result);
            Assert.IsNull(customerLogData);
        }
Esempio n. 14
0
        /// <summary>
        /// Writes structured data to the log with the specified severity and CustomerID.
        /// </summary>
        /// <typeparam name="T">The type of data to write.</typeparam>
        /// <param name="logLevel">The severity of the data.</param>
        /// <param name="objectToSend">The data to log.</param>
        /// <param name="customerID">CustomerID to send with the log</param>
        public void Write <T>(LogLevel logLevel, T objectToSend, Guid customerID)
        {
            var eventType = logLevel.ToTraceEventType();

            if (eventType == null)
            {
                return;
            }

            CustomerLogData data = new CustomerLogData(objectToSend, customerID);

            Write(eventType.Value, data);
        }
Esempio n. 15
0
        /// <summary>
        /// Writes a message to the log with the specified severity and CustomerID.
        /// </summary>
        /// <param name="logLevel">The severity of the message.</param>
        /// <param name="message">The text of the message to log.</param>
        /// <param name="customerID">CustomerID to send with the log</param>
        public void Write(LogLevel logLevel, string message, Guid customerID)
        {
            var eventType = logLevel.ToTraceEventType();

            if (eventType == null)
            {
                return;
            }

            CustomerLogData data = new CustomerLogData(message, customerID);

            Write(eventType.Value, data);
        }
        public void ObjectGetsWrappedInsideCustomerLogData()
        {
            object data = new { Value = "Unit Test Data" };

            System.Diagnostics.TraceSource traceSource = new TraceSource("Test");
            var customerId = Guid.NewGuid();

            traceSource.Attributes["customerid"] = customerId.ToString();
            var result = CustomerLogData.TryParseFromData(traceSource, data, out CustomerLogData customerLogData);

            Assert.IsTrue(result);
            Assert.AreEqual(customerId, customerLogData.CustomerId);
            Assert.AreEqual(data, customerLogData.Data);
        }
        /// <summary>
        /// Enqueues trace information and data to the queue for
        /// asynchronous processing.
        /// </summary>
        /// <param name="e">
        /// A <see cref="TraceListenerBase.TraceEventData"/> object that contains
        /// information about the trace event.
        /// </param>
        /// <param name="data">The trace data to write.</param>
        protected override void TraceInternal(TraceEventData e, object data)
        {
            if (data != null && data is LogData logData)
            {
                TraceInternal(e, logData);
                return;
            }

            var logEntry = new LogEntry
            {
                Level      = e.Type.ToLogLevel(),
                Source     = e.Source,
                EventId    = e.ID,
                ProcessId  = e.Cache.ProcessId,
                ThreadId   = e.Cache.ThreadId,
                CustomerId = e.CustomerID,
                SessionId  = e.SessionID
            };

            if (data is CustomerLogData)
            {
                var content = CustomerLogData.TryExtractCustomerId(data, out Guid? customerId);
                if (content.GetType() == typeof(String) || content.GetType() == typeof(string))
                {
                    logEntry.Message = content.ToString();
                }
                else if (content is LogData dataLogData)
                {
                    logEntry.Message = dataLogData.Message;
                    logEntry.Data    = dataLogData.Data;
                }
                else
                {
                    logEntry.Data = content;
                }
            }
            else
            {
                logEntry.Data = data;
            }

            RequestQueue.Enqueue(logEntry);
        }