示例#1
0
        public static EventLogger UnsafeCreateEventLogger(string eventLogSourceName, DiagnosticTraceBase diagnosticTrace)
        {
            EventLogger logger = new EventLogger();

            logger.SetLogSourceName(eventLogSourceName, diagnosticTrace);
            return(logger);
        }
示例#2
0
        protected static void AddExceptionToTraceString(XmlWriter xml, Exception exception)
        {
            xml.WriteElementString("ExceptionType", DiagnosticTraceBase.XmlEncode(exception.GetType().AssemblyQualifiedName));
            xml.WriteElementString("Message", DiagnosticTraceBase.XmlEncode(exception.Message));
            xml.WriteElementString("StackTrace", DiagnosticTraceBase.XmlEncode(DiagnosticTraceBase.StackTraceString(exception)));
            xml.WriteElementString("ExceptionString", DiagnosticTraceBase.XmlEncode(exception.ToString()));
            Win32Exception win32Exception = exception as Win32Exception;

            if (win32Exception != null)
            {
                int nativeErrorCode = win32Exception.NativeErrorCode;
                xml.WriteElementString("NativeErrorCode", nativeErrorCode.ToString("X", CultureInfo.InvariantCulture));
            }
            if (exception.Data != null && exception.Data.Count > 0)
            {
                xml.WriteStartElement("DataItems");
                foreach (object key in exception.Data.Keys)
                {
                    xml.WriteStartElement("Data");
                    xml.WriteElementString("Key", DiagnosticTraceBase.XmlEncode(key.ToString()));
                    xml.WriteElementString("Value", DiagnosticTraceBase.XmlEncode(exception.Data[key].ToString()));
                    xml.WriteEndElement();
                }
                xml.WriteEndElement();
            }
            if (exception.InnerException != null)
            {
                xml.WriteStartElement("InnerException");
                DiagnosticTraceBase.AddExceptionToTraceString(xml, exception.InnerException);
                xml.WriteEndElement();
            }
        }
示例#3
0
        private static string GetExceptionData(Exception exception)
        {
            string        str;
            StringBuilder stringBuilder = EtwDiagnosticTrace.StringBuilderPool.Take();

            try
            {
                using (StringWriter stringWriter = new StringWriter(stringBuilder, CultureInfo.CurrentCulture))
                {
                    using (XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter))
                    {
                        xmlTextWriter.WriteStartElement("DataItems");
                        foreach (object key in exception.Data.Keys)
                        {
                            xmlTextWriter.WriteStartElement("Data");
                            xmlTextWriter.WriteElementString("Key", DiagnosticTraceBase.XmlEncode(key.ToString()));
                            xmlTextWriter.WriteElementString("Value", DiagnosticTraceBase.XmlEncode(exception.Data[key].ToString()));
                            xmlTextWriter.WriteEndElement();
                        }
                        xmlTextWriter.WriteEndElement();
                        xmlTextWriter.Flush();
                        stringWriter.Flush();
                        str = stringBuilder.ToString();
                    }
                }
            }
            finally
            {
                EtwDiagnosticTrace.StringBuilderPool.Return(stringBuilder);
            }
            return(str);
        }
示例#4
0
 protected void SetTraceSource(TraceSource traceSource)
 {
     if (traceSource != null)
     {
         DiagnosticTraceBase.UnsafeRemoveDefaultTraceListener(traceSource);
         this.traceSource   = traceSource;
         this.haveListeners = this.traceSource.Listeners.Count > 0;
     }
 }
示例#5
0
		public EventLogger(string eventLogSourceName, DiagnosticTraceBase diagnosticTrace)
		{
			try
			{
				this.diagnosticTrace = diagnosticTrace;
				if (EventLogger.canLogEvent)
				{
					this.SafeSetLogSourceName(eventLogSourceName);
				}
			}
			catch (SecurityException securityException)
			{
				EventLogger.canLogEvent = false;
			}
		}
示例#6
0
 public EventLogger(string eventLogSourceName, DiagnosticTraceBase diagnosticTrace)
 {
     try
     {
         this.diagnosticTrace = diagnosticTrace;
         if (EventLogger.canLogEvent)
         {
             this.SafeSetLogSourceName(eventLogSourceName);
         }
     }
     catch (SecurityException securityException)
     {
         EventLogger.canLogEvent = false;
     }
 }
示例#7
0
        public TracePayload GetSerializedPayload(object source, TraceRecord traceRecord, Exception exception, bool getServiceReference)
        {
            string str         = null;
            string str1        = null;
            string traceString = null;

            if (source != null)
            {
                str = DiagnosticTraceBase.CreateSourceString(source);
            }
            if (traceRecord != null)
            {
                StringBuilder stringBuilder = EtwDiagnosticTrace.StringBuilderPool.Take();
                try
                {
                    using (StringWriter stringWriter = new StringWriter(stringBuilder, CultureInfo.CurrentCulture))
                    {
                        using (XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter))
                        {
                            xmlTextWriter.WriteStartElement("ExtendedData");
                            traceRecord.WriteTo(xmlTextWriter);
                            xmlTextWriter.WriteEndElement();
                            xmlTextWriter.Flush();
                            stringWriter.Flush();
                            str1 = stringBuilder.ToString();
                        }
                    }
                }
                finally
                {
                    EtwDiagnosticTrace.StringBuilderPool.Return(stringBuilder);
                }
            }
            if (exception != null)
            {
                traceString = EtwDiagnosticTrace.ExceptionToTraceString(exception, 0x7000);
            }
            if (!getServiceReference || EtwDiagnosticTrace.traceAnnotation == null)
            {
                return(new TracePayload(traceString, str, DiagnosticTraceBase.AppDomainFriendlyName, str1, string.Empty));
            }
            else
            {
                return(new TracePayload(traceString, str, DiagnosticTraceBase.AppDomainFriendlyName, str1, EtwDiagnosticTrace.traceAnnotation()));
            }
        }
示例#8
0
 public EventLogger(string eventLogSourceName, DiagnosticTraceBase diagnosticTrace)
 {
     try
     {
         this.diagnosticTrace = diagnosticTrace;
         //set diagnostics trace prior to calling SafeSetLogSourceName
         if (canLogEvent)
         {
             SafeSetLogSourceName(eventLogSourceName);
         }
     }
     catch (SecurityException)
     {
         // running in PT, do not try to log events anymore
         canLogEvent = false;
         // not throwing exception on purpose
     }
 }
 public EventLogger(string eventLogSourceName, DiagnosticTraceBase diagnosticTrace)
 {
     try
     {
         this.diagnosticTrace = diagnosticTrace;
         //set diagnostics trace prior to calling SafeSetLogSourceName
         if (canLogEvent)
         {
             SafeSetLogSourceName(eventLogSourceName);
         }
     }
     catch (SecurityException)
     {
         // running in PT, do not try to log events anymore
         canLogEvent = false;
         // not throwing exception on purpose
     }
 }       
示例#10
0
        private void SetLevel(SourceLevels level)
        {
            bool         flag;
            SourceLevels sourceLevel = this.FixLevel(level);

            this.level = sourceLevel;
            if (this.TraceSource != null)
            {
                this.haveListeners = this.TraceSource.Listeners.Count > 0;
                this.OnSetLevel(level);
                DiagnosticTraceBase diagnosticTraceBase = this;
                if (!this.HaveListeners)
                {
                    flag = false;
                }
                else
                {
                    flag = level != SourceLevels.Off;
                }
                diagnosticTraceBase.tracingEnabled = flag;
                this.TraceSource.Switch.Level      = level;
            }
        }
示例#11
0
 protected string XmlEncode(string text)
 {
     return(DiagnosticTraceBase.XmlEncode(text));
 }
示例#12
0
		public static EventLogger UnsafeCreateEventLogger(string eventLogSourceName, DiagnosticTraceBase diagnosticTrace)
		{
			EventLogger eventLogger = new EventLogger();
			eventLogger.SetLogSourceName(eventLogSourceName, diagnosticTrace);
			return eventLogger;
		}
示例#13
0
		private void SetLogSourceName(string eventLogSourceName, DiagnosticTraceBase diagnosticTrace)
		{
			this.eventLogSourceName = eventLogSourceName;
			this.diagnosticTrace = diagnosticTrace;
		}
示例#14
0
 private static void WriteExceptionToTraceString(XmlTextWriter xml, Exception exception, int remainingLength, int remainingAllowedRecursionDepth)
 {
     if (remainingAllowedRecursionDepth >= 1)
     {
         if (EtwDiagnosticTrace.WriteStartElement(xml, "Exception", ref remainingLength))
         {
             try
             {
                 List <Tuple <string, string> > tuples = new List <Tuple <string, string> >();
                 tuples.Add(new Tuple <string, string>("ExceptionType", DiagnosticTraceBase.XmlEncode(exception.GetType().AssemblyQualifiedName)));
                 tuples.Add(new Tuple <string, string>("Message", DiagnosticTraceBase.XmlEncode(exception.Message)));
                 tuples.Add(new Tuple <string, string>("StackTrace", DiagnosticTraceBase.XmlEncode(DiagnosticTraceBase.StackTraceString(exception))));
                 tuples.Add(new Tuple <string, string>("ExceptionString", DiagnosticTraceBase.XmlEncode(exception.ToString())));
                 IList <Tuple <string, string> > tuples1 = tuples;
                 Win32Exception win32Exception           = exception as Win32Exception;
                 if (win32Exception != null)
                 {
                     int nativeErrorCode = win32Exception.NativeErrorCode;
                     tuples1.Add(new Tuple <string, string>("NativeErrorCode", nativeErrorCode.ToString("X", CultureInfo.InvariantCulture)));
                 }
                 foreach (Tuple <string, string> tuple in tuples1)
                 {
                     if (EtwDiagnosticTrace.WriteXmlElementString(xml, tuple.Item1, tuple.Item2, ref remainingLength))
                     {
                         continue;
                     }
                     return;
                 }
                 if (exception.Data != null && exception.Data.Count > 0)
                 {
                     string exceptionData = EtwDiagnosticTrace.GetExceptionData(exception);
                     if (exceptionData.Length < remainingLength)
                     {
                         xml.WriteRaw(exceptionData);
                         remainingLength = remainingLength - exceptionData.Length;
                     }
                 }
                 if (exception.InnerException != null)
                 {
                     string innerException = EtwDiagnosticTrace.GetInnerException(exception, remainingLength, remainingAllowedRecursionDepth - 1);
                     if (!string.IsNullOrEmpty(innerException) && innerException.Length < remainingLength)
                     {
                         xml.WriteRaw(innerException);
                     }
                 }
             }
             finally
             {
                 xml.WriteEndElement();
             }
             return;
         }
         else
         {
             return;
         }
     }
     else
     {
         return;
     }
 }
示例#15
0
        public void UnsafeLogEvent(TraceEventType type, ushort eventLogCategory, uint eventId, bool shouldTrace, params string[] values)
        {
            if (logCountForPT < MaxEventLogsInPT)
            {
                try
                {
                    // Vista introduces a new limitation:  a much smaller max
                    // event log entry size that we need to track.  All strings cannot
                    // exceed 31839 characters in length when totalled together.
                    // Choose a max length of 25600 characters (25k) to allow for
                    // buffer since this max length may be reduced without warning.
                    const int MaxEventLogEntryLength = 25600;

                    int eventLogEntryLength = 0;

                    string[] logValues = new string[values.Length + 2];
                    for (int i = 0; i < values.Length; ++i)
                    {
                        string stringValue = values[i];
                        if (!string.IsNullOrEmpty(stringValue))
                        {
                            stringValue = NormalizeEventLogParameter(stringValue);
                        }
                        else
                        {
                            stringValue = String.Empty;
                        }

                        logValues[i]         = stringValue;
                        eventLogEntryLength += stringValue.Length + 1;
                    }

                    string normalizedProcessName = NormalizeEventLogParameter(UnsafeGetProcessName());
                    logValues[logValues.Length - 2] = normalizedProcessName;
                    eventLogEntryLength            += (normalizedProcessName.Length + 1);

                    string invariantProcessId = UnsafeGetProcessId().ToString(CultureInfo.InvariantCulture);
                    logValues[logValues.Length - 1] = invariantProcessId;
                    eventLogEntryLength            += (invariantProcessId.Length + 1);

                    // If current event log entry length is greater than max length
                    // need to truncate to max length.  This probably means that we
                    // have a very long exception and stack trace in our parameter
                    // strings.  Truncate each string by MaxEventLogEntryLength
                    // divided by number of strings in the entry.
                    // Truncation algorithm is overly aggressive by design to
                    // simplify the code change due to Product Cycle timing.
                    if (eventLogEntryLength > MaxEventLogEntryLength)
                    {
                        // logValues.Length is always > 0 (minimum value = 2)
                        // Subtract one to insure string ends in '\0'
                        int truncationLength = (MaxEventLogEntryLength / logValues.Length) - 1;

                        for (int i = 0; i < logValues.Length; i++)
                        {
                            if (logValues[i].Length > truncationLength)
                            {
                                logValues[i] = logValues[i].Substring(0, truncationLength);
                            }
                        }
                    }

                    SecurityIdentifier sid   = WindowsIdentity.GetCurrent().User;
                    byte[]             sidBA = new byte[sid.BinaryLength];
                    sid.GetBinaryForm(sidBA, 0);
                    IntPtr[]   stringRoots       = new IntPtr[logValues.Length];
                    GCHandle   stringsRootHandle = new GCHandle();
                    GCHandle[] stringHandles     = null;

                    try
                    {
                        stringsRootHandle = GCHandle.Alloc(stringRoots, GCHandleType.Pinned);
                        stringHandles     = new GCHandle[logValues.Length];
                        for (int strIndex = 0; strIndex < logValues.Length; strIndex++)
                        {
                            stringHandles[strIndex] = GCHandle.Alloc(logValues[strIndex], GCHandleType.Pinned);
                            stringRoots[strIndex]   = stringHandles[strIndex].AddrOfPinnedObject();
                        }
                        UnsafeWriteEventLog(type, eventLogCategory, eventId, logValues, sidBA, stringsRootHandle);
                    }
                    finally
                    {
                        if (stringsRootHandle.AddrOfPinnedObject() != IntPtr.Zero)
                        {
                            stringsRootHandle.Free();
                        }
                        if (stringHandles != null)
                        {
                            foreach (GCHandle gcHandle in stringHandles)
                            {
                                if (gcHandle != null)
                                {
                                    gcHandle.Free();
                                }
                            }
                        }
                    }

                    if (shouldTrace && this.diagnosticTrace != null && this.diagnosticTrace.IsEnabled())
                    {
                        const int RequiredValueCount            = 4;
                        Dictionary <string, string> eventValues = new Dictionary <string, string>(logValues.Length + RequiredValueCount);
                        eventValues["CategoryID.Name"]  = "EventLogCategory";
                        eventValues["CategoryID.Value"] = eventLogCategory.ToString(CultureInfo.InvariantCulture);
                        eventValues["InstanceID.Name"]  = "EventId";
                        eventValues["InstanceID.Value"] = eventId.ToString(CultureInfo.InvariantCulture);
                        for (int i = 0; i < values.Length; ++i)
                        {
                            eventValues.Add("Value" + i.ToString(CultureInfo.InvariantCulture), values[i] == null ? string.Empty : DiagnosticTraceBase.XmlEncode(values[i]));
                        }

                        this.diagnosticTrace.TraceEventLogEvent(type, new DictionaryTraceRecord((eventValues)));
                    }
                }
                catch (Exception e)
                {
                    if (Fx.IsFatal(e))
                    {
                        throw;
                    }
                    // If not fatal, just eat the exception
                }
                // In PT, we only limit 5 event logging per session
                if (this.isInPartialTrust)
                {
                    logCountForPT++;
                }
            }
        }
示例#16
0
 void SetLogSourceName(string eventLogSourceName, DiagnosticTraceBase diagnosticTrace)
 {
     this.eventLogSourceName = eventLogSourceName;
     this.diagnosticTrace    = diagnosticTrace;
 }
示例#17
0
        public void UnsafeLogEvent(TraceEventType type, ushort eventLogCategory, uint eventId, bool shouldTrace, string[] values)
        {
            string empty;

            if (EventLogger.logCountForPT < 5)
            {
                try
                {
                    int      length    = 0;
                    string[] strArrays = new string[(int)values.Length + 2];
                    for (int i = 0; i < (int)values.Length; i++)
                    {
                        string str = values[i];
                        if (string.IsNullOrEmpty(str))
                        {
                            str = string.Empty;
                        }
                        else
                        {
                            str = EventLogger.NormalizeEventLogParameter(str);
                        }
                        strArrays[i] = str;
                        length       = length + str.Length + 1;
                    }
                    string str1 = EventLogger.NormalizeEventLogParameter(this.UnsafeGetProcessName());
                    strArrays[(int)strArrays.Length - 2] = str1;
                    length = length + str1.Length + 1;
                    int    num  = this.UnsafeGetProcessId();
                    string str2 = num.ToString(CultureInfo.InvariantCulture);
                    strArrays[(int)strArrays.Length - 1] = str2;
                    length = length + str2.Length + 1;
                    if (length > 0x6400)
                    {
                        int length1 = 0x6400 / (int)strArrays.Length - 1;
                        for (int j = 0; j < (int)strArrays.Length; j++)
                        {
                            if (strArrays[j].Length > length1)
                            {
                                strArrays[j] = strArrays[j].Substring(0, length1);
                            }
                        }
                    }
                    SecurityIdentifier user     = WindowsIdentity.GetCurrent().User;
                    byte[]             numArray = new byte[user.BinaryLength];
                    user.GetBinaryForm(numArray, 0);
                    IntPtr[]   intPtrArray   = new IntPtr[(int)strArrays.Length];
                    GCHandle   gCHandle      = new GCHandle();
                    GCHandle[] gCHandleArray = null;
                    try
                    {
                        gCHandle      = GCHandle.Alloc(intPtrArray, GCHandleType.Pinned);
                        gCHandleArray = new GCHandle[(int)strArrays.Length];
                        for (int k = 0; k < (int)strArrays.Length; k++)
                        {
                            gCHandleArray[k] = GCHandle.Alloc(strArrays[k], GCHandleType.Pinned);
                            intPtrArray[k]   = gCHandleArray[k].AddrOfPinnedObject();
                        }
                        this.UnsafeWriteEventLog(type, eventLogCategory, eventId, strArrays, numArray, gCHandle);
                    }
                    finally
                    {
                        if (gCHandle.AddrOfPinnedObject() != IntPtr.Zero)
                        {
                            gCHandle.Free();
                        }
                        if (gCHandleArray != null)
                        {
                            GCHandle[] gCHandleArray1 = gCHandleArray;
                            for (int l = 0; l < (int)gCHandleArray1.Length; l++)
                            {
                                GCHandle gCHandle1 = gCHandleArray1[l];
                                gCHandle1.Free();
                            }
                        }
                    }
                    if (shouldTrace && this.diagnosticTrace != null && this.diagnosticTrace.IsEnabled())
                    {
                        Dictionary <string, string> strs = new Dictionary <string, string>((int)strArrays.Length + 4);
                        strs["CategoryID.Name"]  = "EventLogCategory";
                        strs["CategoryID.Value"] = eventLogCategory.ToString(CultureInfo.InvariantCulture);
                        strs["InstanceID.Name"]  = "EventId";
                        strs["InstanceID.Value"] = eventId.ToString(CultureInfo.InvariantCulture);
                        for (int m = 0; m < (int)values.Length; m++)
                        {
                            Dictionary <string, string> strs1 = strs;
                            string str3 = string.Concat("Value", m.ToString(CultureInfo.InvariantCulture));
                            if (values[m] == null)
                            {
                                empty = string.Empty;
                            }
                            else
                            {
                                empty = DiagnosticTraceBase.XmlEncode(values[m]);
                            }
                            strs1.Add(str3, empty);
                        }
                        this.diagnosticTrace.TraceEventLogEvent(type, new DictionaryTraceRecord(strs));
                    }
                }
                catch (Exception exception1)
                {
                    Exception exception = exception1;
                    if (Fx.IsFatal(exception))
                    {
                        throw;
                    }
                }
                if (this.isInPartialTrust)
                {
                    EventLogger.logCountForPT = EventLogger.logCountForPT + 1;
                }
            }
        }