// first write a space (' ') to all bytes of the byte array
ByteArrayUtils.clear(orderIdByteArray);

// read the string value into the byte array
int orderIdLength = fixMsg.readBytes(FixTags.OrderID, orderIdByteArray);

if (orderIdLength <= 0) {
    // OrderID tag not present... nothing was read...
} else {
    // use the byte array as the key to a ByteArrayMap
    Order order = orderByteArrayMap.get(orderIdByteArray);
    // (...)
}

config.add("readSocketBufferSize", 24 * 1024 * 1024);
config.add("writeSocketBufferSize" 24 * 1024 * 1024);

Client client = new MyClient(nio, "localhost", 44444, config);

You can also overwrite the default value from 12Mb to whatever you want with with the JVM command-line option: -DreadSocketBufferSize and -DwriteSocketBufferSize. Just keep in mind that this will affect only the clients and servers that have not set their own size through the config.

config.add("nic", "p1p4");

Client client = new MyMulticastClient(nio, "224.4.4.4", 44444, config);

By default, a multicast client will join/leave automatically. If you want to join/leave the multicast group yourself you can call the methods join() and leave() manually. To do that pass in the client config:

config.add("joinAutomatically", false);

config.add("isBroadcastAddr", true);

// this method will block, wait for the store queue to be drained and then return
asyncStore.drainAndWait();

// drain and close the the store gracefully
// this method will NOT block, returning immediately, but all messages from the store will
// be processed before the store is closed
asyncStore.close(); // returns immediately, but adds a close event in the queue for this store

// drain and close the the logger gracefully
// this method will block, wait for the queue to be drained, wait for the logger to be closed and then return
 myLogger.drainCloseAndWait();
 
// if you don't want to close, but just want to drain, you can do:
// this method will block, wait for the queue to be drained and then return
myLogger.drainAndWait();

// drain and close the the logger gracefully
// this method will NOT block, returning immediately, but all messages from this logger will
// be processed before the logger is closed
myLogger.close(); // returns immediately, but adds a close event in the queue for this logger

long id = 2342342342;

// autoboxing will happen for id and garbage will be created
myLogger.log("This is a log message!", "user=", "foo", "id=", id);

// NO AUTOBOXING ANYMORE
myLogger.log("This is a log message!", "user=", "foo", "id=", to_sb(id));

LogConfig logConfig = new LogConfig(myDir, myFilename);

// make the logger thread-safe
logConfig.isSynchronized = true; // default is false
 
Logger myLogger = Log.createLogger(logConfig);

// feel free to share myLogger among threads now

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TestSlf4j {
	
	private final Logger logger = LoggerFactory.getLogger(TestSlf4j.class);
	
	public void logSomething() {
		logger.info("This is a intergration test between CoralLog and Slf4j!");
	}
	
	public static void main(String[] args) {
		TestSlf4j test = new TestSlf4j();
		test.logSomething();
	}
}

# CoralLog configuration
logFile = true
logDir = /var/logs/myapps/
logPattern = %p (%D/%M/%Y) - %T - %m%n

    D - day of the month (ex: 23)
    M - month of the year (ex: 02)
    Y - year (ex: 2015)
    T - time in the format HH:MM:SS.SSSSSS (microsecond precision)
    m - the message
    n - carriage return / new line
    p - the log level (INFO, DEBUG, WARN, etc)
    l - the class and line number where the log call was issued (if enabled)
    r - time in milliseconds since the application has started
    e - epoch in microseconds
    i - epoch in milliseconds

So for example the pattern:

---> %p (%D/%M/%Y) - %T - %m%n

would produce:

logger.info("This is a test!"); // output below:
// ---> INFO (05/10/2015) - 12:42:11.080161 - This is a test!"