private bool CheckCommAccess(string serviceName, Type serviceType, string methodName,
    IRServerPrincipal principal)
{
    if (_commPolicies.Length > 0)
    {
        var ctx = new CommPolicyContext(serviceName, serviceType, methodName);
        foreach (var policy in _commPolicies)
            if (!_policyMgr.IsPermitted(_serviceManager, principal, ctx, policy))
                return false;
    }
    return true;
}

<categories>
   <category name="Errors">
      <add name="Common" level="Errors"/>
   </category>
   <category name="Info">
      <add name="Common" level="Errors|Warnings|Info"/>
   </category>
   <category name = "AllDebug">
      <add name="Common" level="Errors|Warnings|Info|Verbose"/>
   </category>
   <category name = "DebugSql">
      <add name="Common" level="Errors|Warnings|Info"/>
      <add name="DAL" level="Errors|Warnings|Info|Verbose"/>
   </category>
</categories>
<listeners>
   <listener name="mail" type="...">
     <server>...
     ....
     <category_ref>Errors</category_ref>
   </listener>
   <listener name="file" type="...">
     <directory>...
     ....
     <category_ref>Info</category_ref>
   </listener>
</listeners>

Немного не понял что такое фильтр лога с лог. выражением. В принципе у логов есть три цели:
1. Информация о текущей работе
2. Нотификация о ошибке
3. Информация о ошибке с максимальным кол-вом информации о выполнении.

<target type="Console">
    <filter>Priority > Normal || (Source == 'SubsystemA' && Priority > Low)</filter>
</target>

GZ>А также быстрый mail сервер.

AVK>><target type="Console">
AVK>>    <filter>Priority > Normal || (Source == 'SubsystemA' && Priority > Low)</filter>
AVK>></target>
AVK>>

namespace R.Server.ServerModel
{
    public enum LogEventType
    {
        Information = 1,
        Warning = 2,
        Error = 3,
        CriticalError = 4
    }
}

Testing Buffered:
Тест Writing:12 ms
RunningThread=602000 cycles; 50166 cycles in ms
Testing NotBuffered:
Тест Writing:2030 ms
RunningThread=96107000 cycles; 47343 cycles in ms
Results:
Buffered time is 0,591133004926108 %
UnBuffered cycles is 94,3726826934577 %

using System;
using System.Text;
using System.Threading;
using System.IO;
using System.Diagnostics;

namespace TestWrite
{
    class Program
    {
        string toWrite;
        long timeWrite = 0;
        long timeBufferedWrite;
        long timeNotBufferedWrite;
        long cyclesInMs;
        long cyclesBuffered;
        long cyclesUnbuffered;
        const int writeCyclesCount = 1000;
        public ManualResetEvent evStart = new ManualResetEvent(false);
        public ManualResetEvent evEnd = new ManualResetEvent(false);
        public void TestWriting(object o)
        {
            bool isBuffered = (bool)o;
            evStart.WaitOne();
            Stopwatch watch = Stopwatch.StartNew();
            if (isBuffered)
                Buffered();
            else
                NotBuffered();
            watch.Stop();
            timeWrite = watch.ElapsedMilliseconds;
            evEnd.Set();
            Console.WriteLine(String.Format("Тест Writing:{0} ms", watch.ElapsedMilliseconds));


            
        }

        private void Buffered()
        {
            using (StreamWriter writer = new StreamWriter(@"c:\test.log", true))
            {
                for (int i = 0; i < writeCyclesCount; i++)
                {
                    writer.WriteLine(toWrite);

                }
            }
        }
        private void NotBuffered()
        {
            for (int i = 0; i < writeCyclesCount; i++)
            {
                using (StreamWriter writer = new StreamWriter(@"c:\test.log", true))
                {
                    writer.WriteLine(toWrite);
                }
            }
        }

        public void RunningThread(object state)
        {
            evStart.WaitOne();
            long j = 0;
            while (j < long.MaxValue)
            {
                j++;
                if (j % 1000 == 0)
                    if (evEnd.WaitOne(0, false))
                        break;
            }
            Console.WriteLine(String.Format("RunningThread={0} cycles; {1} cycles in ms", j, j / timeWrite));
            cyclesInMs = j/timeWrite;
        }

        private void PrepareString()
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 50; i++)
                sb.Append("0123456789");
            toWrite = sb.ToString();
        }

        public void Test()
        {
            PrepareString();
            Console.WriteLine("Testing Buffered:");
            Thread thread1 = new Thread(RunningThread);
            Thread thread2 = new Thread(TestWriting);
            thread2.Start(true);
            thread1.Start();
            evStart.Set();
            thread1.Join();
            thread2.Join();
            cyclesBuffered=cyclesInMs;
            timeBufferedWrite=timeWrite;
            evStart.Reset();
            evEnd.Reset();
            Console.WriteLine("Testing NotBuffered:");
            thread1 = new Thread(RunningThread);
            thread2 = new Thread(TestWriting);
            thread2.Start(false);
            thread1.Start();
            evStart.Set();
            thread1.Join();
            thread2.Join();
            cyclesUnbuffered=cyclesInMs;
            timeNotBufferedWrite=timeWrite;
            Console.WriteLine("Results:");
            Console.WriteLine("Buffered time is {0} %", (double)timeBufferedWrite*100/timeNotBufferedWrite);
            Console.WriteLine("UnBuffered cycles is {0} %", (double)cyclesUnbuffered * 100 / cyclesBuffered);

        }
        static void Main(string[] args)
        {
            new Program().Test();
        }
    }
}

Testing Buffered:
Тест Writing:5 ms
RunningThread=16000 cycles; 3200 cycles in ms
Testing NotBuffered:
Тест Writing:109 ms
RunningThread=16000 cycles; 146 cycles in ms
Results:
Buffered time is 4,58715596330275 %
UnBuffered cycles is 4,5625 %