Example #1
0
        private void StartTracing()
        {
            const uint RealTime    = 0x00000100;
            const uint EventRecord = 0x10000000;

            _logFile                     = new EventTraceLogfile();
            _logFile.LoggerName          = _loggerName;
            _logFile.EventRecordCallback = EventRecordCallback;

            _logFile.ProcessTraceMode = EventRecord | RealTime;
            _traceHandle = NativeMethods.OpenTrace(ref _logFile);

            int error = Marshal.GetLastWin32Error();

            if (error != 0)
            {
                throw new System.ComponentModel.Win32Exception(error);
            }

            _processEventsDelgate = new ProcessTraceDelegate(ProcessTraceInBackground);
            _asyncResult          = _processEventsDelgate.BeginInvoke(_traceHandle, null, _processEventsDelgate);
        }
Example #2
0
        private void StartTracing()
        {
            const uint RealTime          = 0x00000100;
            const uint EventRecord       = 0x10000000;
            const uint BufferSize        = 64;
            const uint MinBuffers        = 20;
            const uint MaxBuffers        = 200;
            const uint FlushTimerSeconds = 1;
            int        status;

            if (!LoadExistingEventTraceProperties())
            {
                this.eventTraceProperties.SetParameters(RealTime, BufferSize, MinBuffers, MaxBuffers, FlushTimerSeconds);

                // Start trace session
                ulong unsafeSessionHandle;
                status = NativeMethods.StartTrace(out unsafeSessionHandle, this.loggerName, ref this.eventTraceProperties);
                if (status != 0)
                {
                    throw new System.ComponentModel.Win32Exception(status);
                }
                this.sessionHandle = new SessionSafeHandle(unsafeSessionHandle, this.loggerName);

                Guid EmptyGuid = Guid.Empty;

                Version Windows7Version = new Version(6, 1, 7600);
                if (Environment.OSVersion.Version.CompareTo(Windows7Version) >= 0)
                {
                    const int             TimeToWaitForInitialize = 10 * 1000;
                    EnableTraceParameters enableParameters        = new EnableTraceParameters();
                    enableParameters.Version        = 1; // ENABLE_TRACE_PARAMETERS_VERSION
                    enableParameters.EnableProperty = EventEnableProperty.Sid;
                    status = NativeMethods.EnableTraceEx2(
                        unsafeSessionHandle,
                        ref this.eventProviderId,
                        1,         // controlCode - EVENT_CONTROL_CODE_ENABLE_PROVIDER
                        (byte)this.Level,
                        this.MatchAnyKeyword,
                        0,         // matchAnyKeyword
                        TimeToWaitForInitialize,
                        ref enableParameters);
                }
                else
                {
                    status = NativeMethods.EnableTraceEx(
                        ref this.eventProviderId,
                        ref EmptyGuid,                  // sourceId
                        unsafeSessionHandle,
                        1,                              // isEnabled
                        (byte)this.Level,
                        this.MatchAnyKeyword,
                        0,                              // matchAllKeywords
                        EventEnableProperty.Sid,
                        IntPtr.Zero);
                }
                if (status != 0)
                {
                    throw new System.ComponentModel.Win32Exception(status);
                }
            }

            this.logFile                     = new EventTraceLogfile();
            this.logFile.LoggerName          = this.loggerName;
            this.logFile.EventRecordCallback = EventRecordCallback;

            this.logFile.ProcessTraceMode = EventRecord | RealTime;
            ulong unsafeTraceHandle = NativeMethods.OpenTrace(ref this.logFile);

            status = Marshal.GetLastWin32Error();
            if (status != 0)
            {
                throw new System.ComponentModel.Win32Exception(status);
            }
            this.traceHandle = new TraceSafeHandle(unsafeTraceHandle);

            this.processEventsDelgate = new ProcessTraceDelegate(ProcessTraceInBackground);
            this.asyncResult          = this.processEventsDelgate.BeginInvoke(this.traceHandle, null, this.processEventsDelgate);
        }
        private void StartTracing()
        {
            const uint RealTime = 0x00000100;
            const uint EventRecord = 0x10000000;
            const uint BufferSize = 64;
            const uint MinBuffers = 20;
            const uint MaxBuffers = 200;
            const uint FlushTimerSeconds = 1;
            int status;

            if (!LoadExistingEventTraceProperties()) {
                this.eventTraceProperties.SetParameters(RealTime, BufferSize, MinBuffers, MaxBuffers, FlushTimerSeconds);

                // Start trace session
                ulong unsafeSessionHandle;
                status = NativeMethods.StartTrace(out unsafeSessionHandle, this.loggerName, ref this.eventTraceProperties);
                if (status != 0) {
                    throw new System.ComponentModel.Win32Exception(status);
                }
                this.sessionHandle = new SessionSafeHandle(unsafeSessionHandle, this.loggerName);

                Guid EmptyGuid = Guid.Empty;

                Version Windows7Version = new Version(6, 1, 7600);
                if (Environment.OSVersion.Version.CompareTo(Windows7Version) >= 0) {
                    const int TimeToWaitForInitialize = 10 * 1000;
                    EnableTraceParameters enableParameters = new EnableTraceParameters();
                    enableParameters.Version = 1; // ENABLE_TRACE_PARAMETERS_VERSION
                    enableParameters.EnableProperty = EventEnableProperty.Sid;
                    status = NativeMethods.EnableTraceEx2(
                                unsafeSessionHandle,
                                ref this.eventProviderId,
                                1, // controlCode - EVENT_CONTROL_CODE_ENABLE_PROVIDER
                                (byte)this.Level,
                                this.MatchAnyKeyword,
                                0, // matchAnyKeyword
                                TimeToWaitForInitialize,
                                ref enableParameters);
                }
                else {
                    status = NativeMethods.EnableTraceEx(
                                ref this.eventProviderId,
                                ref EmptyGuid,          // sourceId
                                unsafeSessionHandle,
                                1,                      // isEnabled
                                (byte)this.Level,
                                this.MatchAnyKeyword,
                                0,                      // matchAllKeywords
                                EventEnableProperty.Sid,
                                IntPtr.Zero);
                }
                if (status != 0) {
                    throw new System.ComponentModel.Win32Exception(status);
                }
            }

            this.logFile = new EventTraceLogfile();
            this.logFile.LoggerName = this.loggerName;
            this.logFile.EventRecordCallback = EventRecordCallback;

            this.logFile.ProcessTraceMode = EventRecord | RealTime;
            ulong unsafeTraceHandle = NativeMethods.OpenTrace(ref this.logFile);
            status = Marshal.GetLastWin32Error();
            if (status != 0) {
                throw new System.ComponentModel.Win32Exception(status);
            }
            this.traceHandle = new TraceSafeHandle(unsafeTraceHandle);

            this.processEventsDelgate = new ProcessTraceDelegate(ProcessTraceInBackground);
            this.asyncResult = this.processEventsDelgate.BeginInvoke(this.traceHandle, null, this.processEventsDelgate);
        }
        private void StartTracing()
        {
            const uint RealTime          = 0x00000100;
            const uint EventRecord       = 0x10000000;
            const uint BufferSize        = 64;
            const uint MinBuffers        = 20;
            const uint MaxBuffers        = 200;
            const uint FlushTimerSeconds = 1;
            int        status;

            if (!LoadExistingEventTraceProperties())
            {
                _eventTraceProperties.SetParameters(RealTime, BufferSize, MinBuffers, MaxBuffers, FlushTimerSeconds);

                // Start trace session
                ulong unsafeSessionHandle;
                status = NativeMethods.StartTrace(
                    out unsafeSessionHandle,
                    _loggerName,
                    ref _eventTraceProperties);
                if (status != 0)
                {
                    throw new Win32Exception(status);
                }

                _sessionHandle = new SessionSafeHandle(unsafeSessionHandle, _loggerName);

                var emptyGuid = Guid.Empty;

                var windows7Version = new Version(6, 1, 7600);
                if (Environment.OSVersion.Version.CompareTo(windows7Version) >= 0)
                {
                    const int TimeToWaitForInitialize = 10 * 1000;
                    var       enableParameters        = new EnableTraceParameters
                    {
                        Version        = 1,
                        EnableProperty = EventEnableProperty.Sid
                    };

                    // ENABLE_TRACE_PARAMETERS_VERSION
                    status = NativeMethods.EnableTraceEx2(
                        unsafeSessionHandle,
                        ref _eventProviderId,
                        1,


                        // controlCode - EVENT_CONTROL_CODE_ENABLE_PROVIDER
                        (byte)Level,
                        MatchAnyKeyword,
                        0,
                        // matchAnyKeyword
                        TimeToWaitForInitialize,
                        ref enableParameters);
                }
                else
                {
                    status = NativeMethods.EnableTraceEx(
                        ref _eventProviderId,
                        ref emptyGuid,
                        // sourceId
                        unsafeSessionHandle,
                        1,
                        // isEnabled
                        (byte)Level,
                        MatchAnyKeyword,
                        0,
                        // matchAllKeywords
                        EventEnableProperty.Sid,
                        IntPtr.Zero);
                }
                if (status != 0)
                {
                    throw new Win32Exception(status);
                }
            }

            _logFile = new EventTraceLogfile
            {
                LoggerName          = _loggerName,
                EventRecordCallback = EventRecordCallback,
                ProcessTraceMode    = EventRecord | RealTime
            };

            var unsafeTraceHandle = NativeMethods.OpenTrace(ref _logFile);

            status = Marshal.GetLastWin32Error();
            if (status != 0)
            {
                throw new Win32Exception(status);
            }

            _traceHandle = new TraceSafeHandle(unsafeTraceHandle);

            _processEventsDelgate = ProcessTraceInBackground;
            _asyncResult          = _processEventsDelgate.BeginInvoke(_traceHandle, null, _processEventsDelgate);
        }