示例#1
0
 internal static void Enter(TraceSource source, string method)
 {
     if(source.Switch.ShouldTrace(TraceEventType.Verbose))
     {
         source.TraceEvent(TraceEventType.Verbose, 0, "Entering --> " + method);
     }
 }
 internal static void Associate(TraceSource traceSource, object objA, object objB)
 {
     if (ValidateSettings(traceSource, TraceEventType.Information))
     {
         PrintLine(traceSource, TraceEventType.Information, 0, "Associating " + (GetObjectName(objA) + "#" + ValidationHelper.HashString(objA)) + " with " + (GetObjectName(objB) + "#" + ValidationHelper.HashString(objB)));
     }
 }
            public void CanDisposeRepeatedly()
            {
                var traceSource = new TraceSource(MethodBase.GetCurrentMethod().Name, SourceLevels.All);

                using (var context = new LogicalOperationScope(traceSource, traceSource.Name))
                    context.Dispose();
            }
示例#4
0
 internal static void Leave(TraceSource source, string message)
 {
     if (source.Switch.ShouldTrace(TraceEventType.Verbose))
     {
         source.TraceEvent(TraceEventType.Verbose, 0, "Leaving <-- " + message);
     }
 }
			public TraceListenerEx(TraceSource source)
			{
				if (source == null)
					throw new ArgumentNullException("source");

				_source = source;
			}
            public void ReturnName()
            {
                var traceSource = new TraceSource(MethodBase.GetCurrentMethod().Name, SourceLevels.All);

                using (var context = new LogicalOperationScope(traceSource, traceSource.Name))
                    Assert.Equal(traceSource.Name, context.ToString());
            }
示例#7
0
 public void SetSourceSwitchTest()
 {
     var trace = new TraceSource("TestTraceSource");
     var @switch = new SourceSwitch("TestTraceSwitch");
     trace.Switch = @switch;
     Assert.Equal(@switch, trace.Switch);
 }
示例#8
0
        public Task Invoke(IDictionary<string, object> env)
        {
            // The TraceSource is assumed to be the same across all requests.

            traceSource = traceSource ?? new Request(env).Get<TraceSource>("host.TraceSource");

            if (traceSource == null)
            {
                return nextApp(env);
            }

            try
            {
                TraceCall(env);
                return nextApp(env).Then(() =>
                {
                    TraceResult(env);
                })
                .Catch(errorInfo =>
                {
                    TraceException(errorInfo.Exception, "asynchronously");
                    return errorInfo.Throw();
                });
            }
            catch (Exception ex)
            {
                TraceException(ex, "synchronously");
                throw;
            }
        }
            public void NewLogicalOperationPushedOnToStack()
            {
                var traceSource = new TraceSource(MethodBase.GetCurrentMethod().Name, SourceLevels.All);

                using (new LogicalOperationScope(traceSource, traceSource.Name))
                    Assert.Equal("NewLogicalOperationPushedOnToStack", Trace.CorrelationManager.LogicalOperationStack.Peek());
            }
        public async Task TestTcpTraceListener()
        {
            var listener = new TcpListener(IPAddress.Loopback, 0);
            listener.Start();
            int port = ((IPEndPoint)listener.Server.LocalEndPoint).Port;


            var traceSource = new TraceSource("UnitTestLogger");
            traceSource.Listeners.Remove("Default");
            traceSource.Switch.Level = SourceLevels.All;
            traceSource.Listeners.Add(new TcpTraceListener(
                                            IPAddress.Loopback, port, 
                                            new ExponentialBackoffTcpReconnectionPolicy()));

            var listenerClient = await listener.AcceptTcpClientAsync();

            traceSource.TraceEvent(TraceEventType.Information, 100, "Boris");

            var receiverReader = new StreamReader(listenerClient.GetStream());
            var line = await receiverReader.ReadLineAsync();

            Assert.True(line.EndsWith("UnitTestLogger Information: 100 : Boris"));

            listenerClient.Close();
            listener.Stop();
            traceSource.Close();
        }
示例#11
0
        public void EmailFloodManyThreadsMax100()
        {
            TraceSource source = new TraceSource("emailFlood2Source");

            Action d = () =>
            {
                try
                {
                    var guid = Guid.NewGuid();
                    source.TraceEvent(TraceEventType.Warning, 0, "Message 1 - {0}", guid);
                    source.TraceEvent(TraceEventType.Error, 0, "Message 2 - {0}", guid);
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(string.Format("Action exception: {0}", ex));
                }
            };

            for (int i = 0; i < 200; i++)
            {
                d.BeginInvoke(null, null);
            }

            // Need to wait, otherwise messages haven't been sent and Assert throws exception
            System.Threading.Thread.Sleep(3000);

            AssertMessagesSent(100, "Should be limited by max traces of 100.");
        }
		public override void Run()
		{
			try
			{
				var m = Helper.FormatTrace("Staring the Scheduler", "SchedulerWorkerRole", "Run");
				var traceSource = new TraceSource("VirtoCommerce.ScheduleService.Trace");
				traceSource.TraceEvent(TraceEventType.Information, 0, m);

				string cloudContext;
				if (RoleEnvironment.IsAvailable)
				{
					cloudContext = String.Format("{0}|{1}",
						RoleEnvironment.DeploymentId,
						RoleEnvironment.CurrentRoleInstance.Id);
				}
				else
				{
					cloudContext = Guid.NewGuid().ToString();
				}

				var jobScheduler = new JobScheduler(cloudContext, traceSource, () => AzureConfiguration.Instance.AzureStorageAccount, new Settings());

                traceSource.TraceEvent(TraceEventType.Information, 0, Helper.FormatTrace("Staring the Scheduler", "SchedulerWorkerRole", "Run", "Starting Paralel.Invoke", cloudContext));

				Parallel.Invoke(
					jobScheduler.JobsManagerProcess,
					jobScheduler.SchedulerProcess);
			}
			catch (Exception ex)
			{
				var m = Helper.FormatException(ex, "WorkerRole", "Run");
				var traceSource = new TraceSource("VirtoCommerce.ScheduleService.Trace");
				traceSource.TraceEvent(TraceEventType.Error, 0, m);
			}
		}
示例#13
0
        static void Main(string[] args)
        {
            EnableSelfSignedCertificates();

            Uri uri = new Uri("https://localhost:8088");
            string token = "BEC47D17-AC4A-49ED-834B-969745D24550";

            var trace = new TraceSource("conf-demo");
            trace.Switch.Level = SourceLevels.All;
            var listener = new HttpEventCollectorTraceListener(uri, token);
            trace.Listeners.Add(listener);

            HashSet<string> files = new HashSet<string>();

            while (true)
            {
                string[] currentFiles = Directory.GetFiles(args[0]);
                foreach (string s in currentFiles)
                {
                    if (!files.Contains(s))
                    {
                        files.Add(s);
                        string ascii = ToAscii(s.Substring(s.LastIndexOf('\\') + 1), new Bitmap(s, true));

                        trace.TraceInformation(ascii);
                        trace.Flush();
                    }
                }
                Thread.Sleep(200);
            }
        }
示例#14
0
        public void ShouldLogNetworkCommunication()
        {
            // Setup source and listener
            string initializationString =
                @"name = XmlLogger; logrootpath = c:\logs\; staticpattern = lognc_; maxSizeBytes = 200000;";

            XmlWriterRollingTraceListener traceListener =
                new XmlWriterRollingTraceListener(initializationString);

            TraceSource log = new TraceSource("Test", SourceLevels.All);

            log.Listeners.Clear();
            log.Listeners.Add(traceListener);

            // Start Activity #1
            Guid activity1Guid = Guid.NewGuid();

            Trace.CorrelationManager.ActivityId = activity1Guid;

            log.TraceEvent(TraceEventType.Start, 2, "Activity #1");

            // log information inside Activity #1
            log.TraceInformation("Going to execute HttpWebRequest from Activity #1");

            HttpWebRequest request = HttpWebRequest.Create("http://www.google.com/") as HttpWebRequest;
            WebResponse response = request.GetResponse();

            using (StreamReader s = new StreamReader(response.GetResponseStream()))
            {
                string value = s.ReadToEnd();
            }

            // Complete Activity #1
            log.TraceEvent(TraceEventType.Stop, 8, "Completing Activity #1");
        }
            public void ActivityIdChangedIfNewGuidSpecified()
            {
                var traceSource = new TraceSource(MethodBase.GetCurrentMethod().Name, SourceLevels.All);
                var activityId = Guid.NewGuid();

                using (new ActivityScope(traceSource, activityId))
                    Assert.Equal(activityId, Trace.CorrelationManager.ActivityId);
            }
示例#16
0
        protected ConnectionBase(TraceSource traceSource)
        {
            this.id = Interlocked.Increment(ref connectionIdCount);

              Interlocked.CompareExchange(ref connectionIdCount, 0, int.MaxValue);

              this.traceSource = traceSource;
        }
示例#17
0
        private static void TraceInternal(TraceSource traceSource, int eventId, TraceLevel traceLevel, string message)
        {
            if (traceSource == null) 
                return;

            var traceEventType = ConvertTraceLevelToTraceEventType(traceLevel);
            traceSource.TraceEvent(traceEventType, eventId, message);
        }
 internal static void Dump(TraceSource traceSource, object obj, string method, byte[] buffer, int offset, int length)
 {
     if (ValidateSettings(traceSource, TraceEventType.Verbose))
     {
         if (buffer == null)
         {
             PrintLine(traceSource, TraceEventType.Verbose, 0, "(null)");
         }
         else if (offset > buffer.Length)
         {
             PrintLine(traceSource, TraceEventType.Verbose, 0, "(offset out of range)");
         }
         else
         {
             PrintLine(traceSource, TraceEventType.Verbose, 0, "Data from " + GetObjectName(obj) + "#" + ValidationHelper.HashString(obj) + "::" + method);
             int maxDumpSizeSetting = GetMaxDumpSizeSetting(traceSource);
             if (length > maxDumpSizeSetting)
             {
                 PrintLine(traceSource, TraceEventType.Verbose, 0, "(printing " + maxDumpSizeSetting.ToString(NumberFormatInfo.InvariantInfo) + " out of " + length.ToString(NumberFormatInfo.InvariantInfo) + ")");
                 length = maxDumpSizeSetting;
             }
             if ((length < 0) || (length > (buffer.Length - offset)))
             {
                 length = buffer.Length - offset;
             }
             if (GetUseProtocolTextSetting(traceSource))
             {
                 string msg = "<<" + WebHeaderCollection.HeaderEncoding.GetString(buffer, offset, length) + ">>";
                 PrintLine(traceSource, TraceEventType.Verbose, 0, msg);
             }
             else
             {
                 do
                 {
                     int num2 = Math.Min(length, 0x10);
                     string str2 = string.Format(CultureInfo.CurrentCulture, "{0:X8} : ", new object[] { offset });
                     for (int i = 0; i < num2; i++)
                     {
                         str2 = str2 + string.Format(CultureInfo.CurrentCulture, "{0:X2}", new object[] { buffer[offset + i] }) + ((i == 7) ? '-' : ' ');
                     }
                     for (int j = num2; j < 0x10; j++)
                     {
                         str2 = str2 + "   ";
                     }
                     str2 = str2 + ": ";
                     for (int k = 0; k < num2; k++)
                     {
                         str2 = str2 + (((buffer[offset + k] < 0x20) || (buffer[offset + k] > 0x7e)) ? '.' : ((char) buffer[offset + k]));
                     }
                     PrintLine(traceSource, TraceEventType.Verbose, 0, str2);
                     offset += num2;
                     length -= num2;
                 }
                 while (length > 0);
             }
         }
     }
 }
            public void DoNotTraceStartEventWhenTracingDisabled()
            {
                var traceSource = new TraceSource(MethodBase.GetCurrentMethod().Name, SourceLevels.All);
                var listener = new FakeTraceListener();

                traceSource.Listeners.Add(listener);
                using (new LogicalOperationScope(traceSource, traceSource.Name, traceEnabled: false))
                    Assert.Equal(0, listener.Messages.Count(m => m.Trim() == $"Logical operation {traceSource.Name} started"));
            }
 internal static void Dump(TraceSource traceSource, object obj, string method, IntPtr bufferPtr, int length)
 {
     if ((ValidateSettings(traceSource, TraceEventType.Verbose) && (bufferPtr != IntPtr.Zero)) && (length >= 0))
     {
         byte[] destination = new byte[length];
         Marshal.Copy(bufferPtr, destination, 0, length);
         Dump(traceSource, obj, method, destination, 0, length);
     }
 }
示例#21
0
 public static void NLogTraceHandler(TraceSource source, TraceLevel traceLevel, Exception exception, string message, params object[] formatArgs)
 {
     var logger = NLog.LogManager.GetLogger(source.Name);
     switch (traceLevel)
     {
         case TraceLevel.Debug:
             if (exception == null)
             {
                 logger.Debug(message, formatArgs);
             }
             else
             {
                 logger.Debug(exception, message, formatArgs);
             }
             break;
         case TraceLevel.Info:
             if (exception == null)
             {
                 logger.Info(message, formatArgs);
             }
             else
             {
                 logger.Info(exception, message, formatArgs);
             }
             break;
         case TraceLevel.Warn:
             if (exception == null)
             {
                 logger.Warn(message, formatArgs);
             }
             else
             {
                 logger.Warn(exception, message, formatArgs);
             }
             break;
         case TraceLevel.Error:
             if (exception == null)
             {
                 logger.Error(message, formatArgs);
             }
             else
             {
                 logger.Error(exception, message, formatArgs);
             }
             break;
         case TraceLevel.Fatal:
             if (exception == null)
             {
                 logger.Fatal(message, formatArgs);
             }
             else
             {
                 logger.Fatal(exception, message, formatArgs);
             }
             break;
     }
 }
示例#22
0
 /// <summary>
 /// 
 /// </summary>
 static SocketClient()
 {
     #if !NETFX_CORE
     TraceSource = new TraceSource("HigLabo.Net.SocketClient");
     #endif
     #if !NETFX_CORE && !DEBUG
     TraceSource.Listeners.Clear();
     #endif
 }
示例#23
0
 // ���O��‚���
 public void Close()
 {
     if (IsInit())
     {
         m_logSrc.Listeners.Clear();
         m_logSrc.Close();
         m_logSrc = null;
     }
 }
示例#24
0
        static void Main(string[] args)
        {
            IPEndPoint serviceEndPoint = new IPEndPoint(IPAddress.Loopback, 25673);

            ChatService service = new ChatService(serviceEndPoint);
            ChatClient client = new ChatClient(serviceEndPoint);

            var trace = new TraceSource("Custom", SourceLevels.All);
            var disposable = service.Start(trace);
            client.Connect();
        }
示例#25
0
 public void PruneTest()
 {
     var strongTrace = new TraceSource("TestTraceSource");
     var traceRef = new WeakReference(new TraceSource("TestTraceSource"));
     Assert.True(traceRef.IsAlive);
     GC.Collect(2);
     Trace.Refresh();
     Assert.False(traceRef.IsAlive);
     GC.Collect(2);
     Trace.Refresh();
 }
示例#26
0
				public async Task ConnectAsync(string connectionString, TraceSource trace)
        {
            _connection = await ConnectToRedis(connectionString);
            _connection.ConnectionFailed += OnConnectionFailed;
            _connection.ConnectionRestored += OnConnectionRestored;
            _connection.ErrorMessage += OnError;

            _trace = trace;

            _redisSubscriber = _connection.GetSubscriber();
        }
示例#27
0
 public void TraceInformationTest()
 {
     var trace = new TraceSource("TestTraceSource", SourceLevels.All);
     var listener = new TestTraceListener();
     trace.Listeners.Add(listener);
     trace.TraceInformation("message");
     Assert.Equal(0, listener.GetCallCount(Method.TraceData));
     Assert.Equal(0, listener.GetCallCount(Method.Write));
     Assert.Equal(1, listener.GetCallCount(Method.TraceEvent));
     trace.TraceInformation("format", "arg1", "arg2");
     Assert.Equal(2, listener.GetCallCount(Method.TraceEvent));
 }
        public void TraceSource_Accepts_Custom_TraceSource()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter();
            TraceSource traceSource = new TraceSource("CustomTraceSource");

            // Act
            writer.TraceSource = traceSource;

            // Assert
            Assert.Equal(traceSource, writer.TraceSource);
        }
示例#29
0
        public void EmailFilterSendFiltered()
        {
            TraceSource source = new TraceSource("emailFilterSource");

            source.TraceEvent(TraceEventType.Error, 0, "Include Error.");
            source.TraceInformation("Include Info.");
            source.TraceEvent(TraceEventType.Verbose, 0, "Default filter does not include Verbose.");

            System.Threading.Thread.Sleep(2000);//need to wait, otherwise the test host is terminated resulting in thread abort.

            AssertMessagesSent(2);
        }
            public void DoNotTraceTransferIfTracingDisabled()
            {
                var traceSource = new TraceSource(MethodBase.GetCurrentMethod().Name, SourceLevels.All);
                var listener = new FakeTraceListener();
                var activityId = Guid.NewGuid();

                traceSource.Listeners.Add(listener);

                Trace.CorrelationManager.ActivityId = activityId;
                using (new ActivityScope(traceSource, Guid.NewGuid(), traceEnabled: false))
                    Assert.Equal(0, listener.Messages.Count(m => m == String.Format("Transfer from {0} to {1}, relatedActivityId={1}", activityId, activityId)));
            }
示例#31
0
 public static void TraceWarning(this TraceSource traceSource, string message)
 {
     traceSource.TraceEvent(TraceEventType.Warning, (int)TraceEventType.Warning, message);
 }
 public TraceCorrelation(TraceSource source, string activityName)
     : this(Guid.NewGuid(), source, activityName)
 {
 }
 public TraceCorrelation(Guid activity, TraceSource source, string activityName)
 {
     _Source       = source;
     _ActivityName = activityName;
     this.activity = activity;
 }
示例#34
0
 static Trace()
 {
     _source = new TraceSource("dk.nita.saml20");
 }
 static TraceSourceLogger()
 {
     _source = new TraceSource("Thinktecture.IdentityServer");
 }
示例#36
0
 public static TraceCallScope TraceMethod(
     this TraceSource source,
     [CallerMemberName] string method = null)
 {
     return(new TraceCallScope(source, method));
 }
        public TraceLogger(string logName)
        {
            this._logName = "[" + (logName ?? string.Empty) + "] ";

            this.traceSource = new TraceSource("TraceLogger", SourceLevels.All);
        }
示例#38
0
 static Storage()
 {
     Trace = new TraceSource("Storage", SourceLevels.All);
 }
 public TraceSourceLogger(TraceSource traceSource)
 {
     this.traceSource = traceSource;
 }
示例#40
0
 /// <summary>
 /// Writes an error message to the specified trace.
 /// </summary>
 /// <param name="trace">The trace.</param>
 /// <param name="source">Subsystem name to help with log categorizing, filtering</param>
 /// <param name="id">The event identifier.</param>
 /// <param name="messageFormat">Format of the string field</param>
 /// <param name="args">String format arguments</param>
 public static void Maintenance(this TraceSource trace, string source, int id, string messageFormat, params object[] args)
 {
     trace.TraceEvent(TraceEventType.Critical, id, FormatMessage2(source, messageFormat, args));
 }
示例#41
0
 /// <summary>
 /// Writes an error message to the specified trace.
 /// </summary>
 /// <param name="trace">The trace.</param>
 /// <param name="source">Subsystem name to help with log categorizing, filtering</param>
 /// <param name="id">The event identifier.</param>
 /// <param name="ex">The exception to log</param>
 public static void Error(this TraceSource trace, string source, int id, Exception ex)
 {
     //trace.TraceData(TraceEventType.Error, id, FormatMessage(source, "{0}", ex));
     trace.TraceEvent(TraceEventType.Error, id, FormatMessage(source, "{0}", ex));
 }
示例#42
0
 /// <summary>
 /// Writes an error message to the specified trace.
 /// </summary>
 /// <param name="trace">The trace.</param>
 /// <param name="source">Subsystem name to help with log categorizing, filtering</param>
 /// <param name="id">The event identifier.</param>
 /// <param name="messageFormat">Format of the string field</param>
 /// <param name="args">String format arguments</param>
 public static void Error(this TraceSource trace, string source, int id, string messageFormat, params object[] args)
 {
     trace.TraceEvent(TraceEventType.Error, id, FormatMessage(source, messageFormat, args));
 }
示例#43
0
 public Log(TraceSource source, string prefix)
 {
     this.source = source;
     this.prefix = prefix;
 }
示例#44
0
 /// <summary>
 /// Writes an error message to the specified trace.
 /// </summary>
 /// <param name="trace">The trace.</param>
 /// <param name="source">Subsystem name to help with log categorizing, filtering</param>
 /// <param name="messageFormat">Format of the string field</param>
 /// <param name="args">String format arguments</param>
 public static void Error(this TraceSource trace, string source, string messageFormat, params object[] args)
 {
     trace.TraceEvent(TraceEventType.Warning, Thread.CurrentThread.ManagedThreadId, FormatMessage(source, messageFormat, args));
 }
 static TraceSourceLogger()
 {
     _source = new TraceSource("IdentityManager");
 }
示例#46
0
 public static void TraceVerbose(this TraceSource traceSource, string message)
 {
     traceSource.TraceEvent(TraceEventType.Verbose, (int)TraceEventType.Verbose, message);
 }
示例#47
0
 public SystemTraceSink(TraceSource traceSource)
 {
     _traceSource = traceSource;
 }
    public async Task InitializeAsync()
    {
        Tuple <Nerdbank.FullDuplexStream, Nerdbank.FullDuplexStream> streams = Nerdbank.FullDuplexStream.CreateStreams();

        TraceSource mxServerTraceSource = new TraceSource("MX Server", SourceLevels.Information);
        TraceSource mxClientTraceSource = new TraceSource("MX Client", SourceLevels.Information);

        mxServerTraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
        mxClientTraceSource.Listeners.Add(new XunitTraceListener(this.Logger));

        MultiplexingStream[] mxStreams = await Task.WhenAll(
            MultiplexingStream.CreateAsync(
                streams.Item1,
                new MultiplexingStream.Options
        {
            TraceSource = mxServerTraceSource,
            DefaultChannelTraceSourceFactory = (id, name) => new TraceSource("MX Server channel " + id, SourceLevels.Verbose)
            {
                Listeners = { new XunitTraceListener(this.Logger) }
            },
        },
                this.TimeoutToken),
            MultiplexingStream.CreateAsync(
                streams.Item2,
                new MultiplexingStream.Options
        {
            TraceSource = mxClientTraceSource,
            DefaultChannelTraceSourceFactory = (id, name) => new TraceSource("MX Client channel " + id, SourceLevels.Verbose)
            {
                Listeners = { new XunitTraceListener(this.Logger) }
            },
        },
                this.TimeoutToken));

        this.serverMx = mxStreams[0];
        this.clientMx = mxStreams[1];

        MultiplexingStream.Channel[] rpcStreams = await Task.WhenAll(
            this.serverMx.AcceptChannelAsync(string.Empty, this.TimeoutToken),
            this.clientMx.OfferChannelAsync(string.Empty, this.TimeoutToken));

        MultiplexingStream.Channel rpcServerStream = rpcStreams[0];
        MultiplexingStream.Channel rpcClientStream = rpcStreams[1];

        var serverFormatter = new JsonMessageFormatter {
            MultiplexingStream = this.serverMx
        };
        var clientFormatter = new JsonMessageFormatter {
            MultiplexingStream = this.clientMx
        };

        var serverHandler = new HeaderDelimitedMessageHandler(rpcServerStream, serverFormatter);
        var clientHandler = new HeaderDelimitedMessageHandler(rpcClientStream, clientFormatter);

        this.serverRpc = new JsonRpc(serverHandler, this.server);
        this.clientRpc = new JsonRpc(clientHandler);

        this.serverRpc.TraceSource = new TraceSource("Server", SourceLevels.Information);
        this.clientRpc.TraceSource = new TraceSource("Client", SourceLevels.Information);

        this.serverRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
        this.clientRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger));

        this.serverRpc.StartListening();
        this.clientRpc.StartListening();
    }
 /// <summary>
 /// Constructor. Sets the ActivityId for the life of the object, logging events but without specific event IDs.
 /// </summary>
 public ActivityScope(TraceSource source)
     : this(new TraceSourceWrapper(source), 0, 0, 0, 0, null, null, null, null, null)
 {
 }
示例#50
0
        public static bool ShouldTrace(this TraceSource source, MessageId id)
        {
            Contract.Assert(source != null);

            return(source.Switch.ShouldTrace(_typeTable[id]));
        }
示例#51
0
 static Log()
 {
     TraceSource = new TraceSource("EarnTraceSource", SourceLevels.All);
 }
 public ActivityScope(TraceSource source, int transferInId, int startId, int transferOutId, int stopId)
     : this(new TraceSourceWrapper(source), transferInId, startId, transferOutId, stopId,
            null, null, null, null, null)
 {
 }
示例#53
0
 public CalculatorService()
 {
     ts = new TraceSource("ServerCalculatorTraceSource");
 }
 public ActivityScope(TraceSource source, int transferInId, int startId, int transferOutId, int stopId,
                      string transferInMessage, string startMessage, string transferOutMessage, string stopMessage)
     : this(new TraceSourceWrapper(source), transferInId, startId, transferOutId, stopId,
            transferInMessage, startMessage, transferOutMessage, stopMessage, null)
 {
 }
        public static IObservable <T> TraceOnCompleted <T>(this IObservable <T> source, TraceSource trace,
                                                           Func <string> messageSelector)
        {
            Contract.Requires(source != null);
            Contract.Requires(trace != null);
            Contract.Requires(messageSelector != null);
            Contract.Ensures(Contract.Result <IObservable <T> >() != null);

            return(source.Do(new TraceObserver <T>(trace, _ => null, messageSelector)));
        }
示例#56
0
        private static void Main(string[] args)
        {
            string            dt  = $"{DateTime.Now.Hour}{DateTime.Now.Minute}{DateTime.Now.Second}";
            FileSystemHandler fsh = new FileSystemHandler(new FSHandlerOptions("c:\\Temp\\votalot\\dummy" + dt + ".log"));

            fsh.SetFormatter(new FlimFlamV2Formatter());
            Bilge.AddMessageHandler(new ConsoleHandler());
            Bilge.AddMessageHandler(new TCPHandler("127.0.0.1", 9060));
            Bilge.AddMessageHandler(fsh);
            Bilge.Alert.Online("TestClient");

#if CORE
            // Due to the dependency on configurations and the different ways that you can configure a core service this is not
            // implemented within Bilge even as a default but is documented instead.
            Bilge.SetConfigurationResolver((s, lvl) => {
                var configuration = new ConfigurationBuilder()
                                    .AddJsonFile("appsettings.json", false, true)
                                    .Build();

                SourceLevels result            = lvl;
                string defaultValue            = configuration["logging:loglevel:default"];
                string specificForThisInstance = configuration[$"logging:loglevel:{s}"];

                if (Enum.TryParse <SourceLevels>(specificForThisInstance, out SourceLevels slSpecific))
                {
                    result = slSpecific;
                }
                else
                {
                    if (Enum.TryParse <SourceLevels>(defaultValue, out SourceLevels slDefault))
                    {
                        result = slDefault;
                    }
                }

                return(result);
            });
#else
            Bilge.SetConfigurationResolver((instanceName, lvl) => {
                // Logic -> Try Source Switch, Failing that Trace Switch, failing that SourceSwitch + Switch, Failing that TraceSwitch+Switch.

                SourceLevels result   = lvl;
                bool tryTraceSwitches = true;

                try {
                    SourceSwitch ss = new SourceSwitch(instanceName);
                    if (ss.Level == SourceLevels.Off)
                    {
                        ss = new SourceSwitch($"{instanceName}Switch");
                        if (ss.Level == SourceLevels.Off)
                        {
                        }
                        else
                        {
                            tryTraceSwitches = false;
                            result           = ss.Level;
                        }
                    }
                    else
                    {
                        tryTraceSwitches = false;
                        result           = ss.Level;
                    }
                } catch (SystemException) {
                    // This is the higher level exception of a ConfigurationErrorsException but that one requires a separate reference
                    // This occurs when a TraceSwitch has the same name as the source switch with a value that is not supported by source switch e.g. Info
                }

                if (tryTraceSwitches)
                {
                    TraceSwitch ts = new TraceSwitch(instanceName, "");
                    if (ts.Level == TraceLevel.Off)
                    {
                        ts = new TraceSwitch($"{instanceName}Switch", "");
                        if (ts.Level != TraceLevel.Off)
                        {
                            result = Bilge.ConvertTraceLevel(ts.Level);
                        }
                    }
                    else
                    {
                        result = Bilge.ConvertTraceLevel(ts.Level);
                    }
                }

                return(result);
            });
#endif

            Bilge b = new Bilge("PliskyConsoleTestApp");
            b.ActiveTraceLevel = SourceLevels.Verbose;

            b.Verbose.Log("Hello Cruel World");

            bool traceSwitchTests   = false;
            bool bulkFileWriteTests = false;
            bool perfTests          = false;
            bool basicWriteAllTest  = true;
            bool actionTest         = true;

            if (actionTest)
            {
                int acCount = 0;


                b.Action.RegisterHandler((m) => {
                    if (m.Success)
                    {
                        acCount++;
                    }
                }, "bob");

                b.Action.Occured("Event", "Data");


                if (acCount == 0)
                {
                    throw new InvalidOperationException("didnt work");
                }
            }


            if (basicWriteAllTest)
            {
                Bilge.SetConfigurationResolver((instanceName, lvl) => {
                    return(SourceLevels.Verbose);
                });

                ModularWriting mw = new ModularWriting();
                mw.DoWrite();
            }
            if (bulkFileWriteTests)
            {
                ProductionLoggingTest(b);
            }
            b.Flush();

            if (perfTests)
            {
                PerformanceTest p = new PerformanceTest();
                p.AnalysisBatchVsNoBatch();
                //p.ExecuteTest();
                p.WriteOutput();

                Bilge.ForceFlush();
            }
            Console.ReadLine();
            return;

            b.AddHandler(new SimpleTraceFileHandler(@"c:\temp\"));
            if (traceSwitchTests)
            {
                Console.WriteLine("Actual Trace Level : " + b.ActiveTraceLevel.ToString());

                try {
                    TraceSource ts = new TraceSource("monkeySwitch", SourceLevels.Off);
                    TraceSwitch tx = new TraceSwitch("monkey2Switch", "test", "Off");

                    SourceSwitch sw = new SourceSwitch("boner", "off");

                    Console.WriteLine($"{ts.Switch.Level} >> {tx.Level} >> {sw.Level}");

                    Console.ReadLine();
                } catch (Exception ex) {
                }
            }

            bool doDirectWriting = false;

            if (args.Length > 0)
            {
                if (args[0] == "direct")
                {
                    doDirectWriting = true;
                }
            }

            if (doDirectWriting)
            {
                var dr = new DirectWriting(b);
                dr.DoDirectWrites();
            }

            ModularWriting mr = new ModularWriting();
            mr.DoWrite();
            b.Flush();
            Console.WriteLine("Readline");
            Console.ReadLine();
        }
示例#57
0
 /// <summary>
 /// Create a new instance of this trace manager
 /// </summary>
 public TraceManager()
 {
     // Create default source
     source = new TraceSource("LMS");
 }
示例#58
0
 private Logger()
 {
     _traceSource = new TraceSource("Workflow");
 }
示例#59
0
 /// <summary>
 /// Writes an error message to the specified trace.
 /// </summary>
 /// <param name="trace">The trace.</param>
 /// <param name="source">Subsystem name to help with log categorizing, filtering</param>
 /// <param name="ex">The exception to log</param>
 public static void Error(this TraceSource trace, string source, Exception ex)
 {
     trace.TraceData(TraceEventType.Error, Thread.CurrentThread.ManagedThreadId, FormatMessage(source, "{0}", ex));
 }
示例#60
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TypeWrapper"/> class.
 /// </summary>
 /// <param name="type">
 /// Type to be wrapped.
 /// </param>
 public TypeWrapper(TypeDefinition type)
 {
     this.m_Type        = type;
     this.m_Module      = type.Module;
     this.m_TraceSource = new TraceSource("TypeWrapper");
 }