public String GetKey(TraceEvent traceEvent)
 {
     // Original code combined the Provider GUID with the machine name
       // but you cannot mix events with different partition keys in the same
       // batch.
       return Environment.MachineName;
 }

 public void Send(TraceEvent eventData)
 {
     lock (this.eventList)
     {
         this.EventList.Add(eventData);
     }
 }

 public string Format(TraceEvent traceEvent)
 {
     //string ret = format;
     return format.
         Replace("{%ContextHolderId}", traceEvent.ContextIdentifier.ContextHolderId.ToString()).
         Replace("{%ExternalId}", traceEvent.ContextIdentifier.ExternalId.ToString()).
         Replace("{%ExternalReference}", traceEvent.ContextIdentifier.ExternalReference.ToString()).
         Replace("{%ExternalParentId}", traceEvent.ContextIdentifier.ExternalParentId.ToString()).
         Replace("{%InternalId}", traceEvent.ContextIdentifier.InternalId.ToString()).
         Replace("{%InternalParentId}", traceEvent.ContextIdentifier.InternalParentId.ToString()).
         Replace("{%ContextGuid}", traceEvent.ContextIdentifier.ContextGuid.ToString()).
         Replace("{%HostName}", traceEvent.Location.HostName).
         Replace("{%ModulePath}", traceEvent.Location.ModulePath).
         Replace("{%Principal}", traceEvent.Principal.Name).
         Replace("{%ThreadName}", traceEvent.Location.ThreadName).
         Replace("{%Message}", traceEvent.Message).
         Replace("{%Source}", traceEvent.Location.Source).
         Replace("{%Type}", traceEvent.Type.ToString()).
         Replace("{%Category}", traceEvent.Category.ToString()).
         Replace("{%EventIdText}", traceEvent.EventIdText).
         Replace("{%Time}", traceEvent.Time.ToString("dd-MMM-yyyyTHH:mm:ss (fff)")).
         Replace("{%EventId}", traceEvent.EventId.ToString()
         );
     // TODO: Provide specific format handling for the DateTime (SD)
 }

 public override void BeginIteration(TraceEvent beginEvent)
 {
     _objects = new ListMetricInfo();
     _objects.clear();
     _objects.hasCount = true;
     _objects.hasBytes = true;
 }

 public InstanceConfiguration(DataSetConfiguration dataSet, ObservableCollection<MessageHandlerConfiguration> availableHandlers, TraceEvent trace, Action onModification)
 {
     AvailableMessageHandlers = availableHandlers;
     AssociatedMessageHandlers = new ObservableCollection<MessageHandlerConfiguration>(availableHandlers.Where<MessageHandlerConfiguration>(x => x.Associated(dataSet.AssociationName)).ToArray<MessageHandlerConfiguration>());
     DataSetConfiguration = dataSet;
     PropertyChanged += (x, y) => onModification();
 }

 public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
 {
     var te = new TraceEvent {Cache = eventCache, Source = source, Type = eventType, Id = id};
     Events.Add(te);
     if (OnEventAdd != null)
         OnEventAdd.Invoke(te);
 }

        /// <inheritdoc/>
        public override void Trace(TraceEvent traceEvent)
        {
            if (traceEvent == null)
            {
                throw new ArgumentNullException("traceEvent");
            }

            if (ShouldIgnore(traceEvent))
            {
                return;
            }

            try
            {
                foreach (TraceFilter filter in Filters)
                {
                    // trace must be passed to all filters (even if no notifications will be
                    // performed due to throttling) to allow them to continue to accumulate their results
                    if (filter.Filter(traceEvent))
                    {
                        // Notify all subscribers
                        Notify(filter);
                    }
                }
            }
            catch
            {
                // Need to prevent infinite loops when calling out to user code
                // I.e., user code exception in error handler causes error filter/subscriber
                // to be called again.
            }
        }

        private void EventReceived(TraceEvent traceEvent)
        {
            DisplayTraceEvent dte = new DisplayTraceEvent
            {
                TraceEvent = traceEvent,
            };

            foreach (IDisplayTraceEvents idt in _viewers)
            {
                if (idt.IsApplicable(traceEvent))
                {
                    dte.DisplayTemplates.Add(idt.GetDisplayTemplate());

                    DataTemplate listTemplate = idt.GetListItemTemplate();

                    if (listTemplate != null)
                    {
                        dte.ListTemplate = listTemplate;
                    }
                }
            }

            DisplayTraceEvents.Add(dte);
            SelectedTab = 0;
        }

 public override void Trace(TraceEvent traceEvent)
 {
     // TODO: figure out the right log file format
     // TODO: buffer logs and write only periodically
     AppendLine(traceEvent.Message);
     if (traceEvent.Exception != null)
     {
         if (traceEvent.Exception is FunctionInvocationException ||
             traceEvent.Exception is AggregateException)
         {
             // we want to minimize the stack traces for function invocation
             // failures, so we drill into the very inner exception, which will
             // be the script error
             Exception actualException = traceEvent.Exception;
             while (actualException.InnerException != null)
             {
                 actualException = actualException.InnerException;
             }
             AppendLine(actualException.Message);
         }
         else
         {
             AppendLine(traceEvent.Exception.ToString());
         }
     }
 }

        protected override void InvokeTextWriter(TraceEvent traceEvent)
        {
            if (MapTraceLevel(traceEvent.Source, traceEvent.Level) <= _traceConfig.ConsoleLevel)
            {
                // For Errors/Warnings we change the Console color
                // for visibility
                var holdColor = Console.ForegroundColor;
                bool changedColor = false;
                switch (traceEvent.Level)
                {
                    case TraceLevel.Error:
                        Console.ForegroundColor = ConsoleColor.Red;
                        changedColor = true;
                        break;
                    case TraceLevel.Warning:
                        Console.ForegroundColor = ConsoleColor.Yellow;
                        changedColor = true;
                        break;
                }

                base.InvokeTextWriter(traceEvent);

                if (changedColor)
                {
                    Console.ForegroundColor = holdColor;
                }
            }         
        }

 public override void Write(string message)
 {
     var te = new TraceEvent
                  {Cache = new TraceEventCache(), Message = message, Type = TraceEventType.Information};
     Events.Add(te);
     if (OnEventAdd != null)
         OnEventAdd.Invoke(te);
 }

 public unsafe ProcessAction(TraceEvent traceEvent)
 {
     EventName = traceEvent.EventName;
     OpcodeName = traceEvent.OpcodeName;
     PayloadNames = traceEvent.PayloadNames;
     //
     AffectedKeys = new AffectedKeys(traceEvent);
 }

 public override void Write(string message)
 {
     TraceEvent te = new TraceEvent();
     te.Cache = new TraceEventCache();
     te.Message = message;
     te.Type = TraceEventType.Information;
     Events.Add(te);
     if(OnEventAdd != null)
         OnEventAdd.Invoke(te);
 }

        public override void Trace(TraceEvent traceEvent)
        {
            if (Level < traceEvent.Level)
            {
                return;
            }

            _interceptor(traceEvent);
            InnerWriter.Trace(traceEvent);
        }

 public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
 {
     TraceEvent te = new TraceEvent();
     te.Cache = eventCache;
     te.Source = source;
     te.Type = eventType;
     te.ID = id;
     Events.Add(te);
     if(OnEventAdd != null)
         OnEventAdd.Invoke(te);
 }

 protected virtual void InvokeTraceWriters(TraceEvent traceEvent)
 {
     foreach (TraceWriter traceWriter in _innerTraceWriters)
     {
         // filter based on level before delegating
         if (traceWriter.Level >= traceEvent.Level)
         {
             traceWriter.Trace(traceEvent);
         }
     }
 }

		public void Trace(TraceEvent traceEvent)
		{
			foreach (var source in this.sources)
			{
				var diagnostics = source as IDiagnosticsTraceSource;
				if (diagnostics != null)
					diagnostics.Trace(this.originalSourceName, traceEvent);
				else
					source.Trace(traceEvent);
			}
		}

        public override void Trace(TraceEvent traceEvent)
        {
            if (Level < traceEvent.Level)
            {
                return;
            }

            if (_predicate(traceEvent))
            {
                InnerWriter.Trace(traceEvent);
            }
        }

 public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
 {
     var te = new TraceEvent {Cache = eventCache, Source = source, Type = eventType, Id = id};
     Events.Add(te);
     try
     {
         if (Events.Count > 1000)
             Events.RemoveAt(0);
     }
     catch (Exception) { }
     if (OnEventAdd != null)
         OnEventAdd.Invoke(te);
 }

        public override void Trace(TraceEvent traceEvent)
        {
            if (traceEvent == null)
            {
                throw new ArgumentNullException("traceEvent");
            }

            // Apply our top level trace filter first
            if (Level >= traceEvent.Level)
            {
                InvokeTraceWriters(traceEvent);
                InvokeTextWriter(traceEvent);
            }
        }