<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements. See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache license, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License. You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the license for the specific language governing permissions and
  limitations under the license.
  -->
<Configuration status="OFF">
  <Appenders>
    <RandomAccessFile name="RandomAccessFile" fileName="perftest.log" immediateFlush="false" append="false">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %X{aKey} %m %ex%n</Pattern>
      </PatternLayout>
    </RandomAccessFile>
    <Async name="Async"  blocking="true" bufferSize="262144">
      <appender-ref ref="RandomAccessFile"/>
    </Async>
  </Appenders>
  <Loggers>
    <Root level="info" includeLocation="false">
      <appender-ref ref="Async"/>
    </Root>
  </Loggers>
</Configuration>
