Index: src/main/java/ch/qos/logback/classic/spi/LoggingEvent.java
===================================================================
--- src/main/java/ch/qos/logback/classic/spi/LoggingEvent.java	(revision 1629)
+++ src/main/java/ch/qos/logback/classic/spi/LoggingEvent.java	(working copy)
@@ -10,20 +10,19 @@
 
 package ch.qos.logback.classic.spi;
 
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import org.slf4j.MDC;
+import org.slf4j.Marker;
+import org.slf4j.helpers.MessageFormatter;
+import org.slf4j.impl.LogbackMDCAdapter;
+
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.util.Map;
 
-import org.slf4j.MDC;
-import org.slf4j.Marker;
-import org.slf4j.helpers.MessageFormatter;
-import org.slf4j.impl.LogbackMDCAdapter;
-
-import ch.qos.logback.classic.Level;
-import ch.qos.logback.classic.Logger;
-
 /**
  * The internal representation of logging events. When an affirmative decision
  * is made to log then a <code>LoggingEvent</code> instance is created. This
@@ -113,12 +112,16 @@
 
     // bug 85 (we previously failed to set this.argumentArray)
     this.argumentArray = argArray;
-    
-    if (argArray != null) {
-      formattedMessage = MessageFormatter.arrayFormat(message, argArray);
+
+    // formattedMessage is initialized lazily in getFormattedMessage
+    /*
+    if (argumentArray != null) {
+      formattedMessage = MessageFormatter.arrayFormat(message, argumentArray);
     } else {
       formattedMessage = message;
     }
+    */
+
     timeStamp = System.currentTimeMillis();
 
     // the case is ugly but under the circumstances acceptable
@@ -236,7 +239,7 @@
    * 
    * @return The time as measured when this class was loaded into memory.
    */
-  public static final long getStartTime() {
+  public static long getStartTime() {
     return startTime;
   }
 
@@ -276,6 +279,13 @@
   }
 
   public String getFormattedMessage() {
+    if(formattedMessage == null) {
+      if (argumentArray != null) {
+        formattedMessage = MessageFormatter.arrayFormat(message, argumentArray);
+      } else {
+        formattedMessage = message;
+      }
+    }
     return formattedMessage;
   }
 
@@ -284,6 +294,17 @@
   }
 
   private void writeObject(ObjectOutputStream out) throws IOException {
+    // fix for bug #100 & bug #118
+    if(argumentArray!=null) {
+      for(int i=0;i<argumentArray.length;i++) {
+        if(argumentArray[i] != null && !(argumentArray[i] instanceof String)) {
+          argumentArray[i] = argumentArray[i].toString();
+        }
+      }
+    }
+    // clear formattedMessage to safe space in serialized event.
+    // is recreated on demand by getFormattedMessage.
+    formattedMessage = null;
     out.defaultWriteObject();
     out.writeInt(level.levelInt);
   }
Index: src/test/java/ch/qos/logback/classic/spi/LoggingEventTest.java
===================================================================
--- src/test/java/ch/qos/logback/classic/spi/LoggingEventTest.java	(revision 0)
+++ src/test/java/ch/qos/logback/classic/spi/LoggingEventTest.java	(revision 0)
@@ -0,0 +1,114 @@
+package ch.qos.logback.classic.spi;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import junit.framework.TestCase;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.util.Arrays;
+
+public class LoggingEventTest
+  extends TestCase {
+  final Logger logger = (Logger) LoggerFactory.getLogger(LoggingEventTest.class);
+
+  public void testSimpleSerialize() throws IOException, ClassNotFoundException {
+	String fqcn="fqcn";
+	Level level= Level.DEBUG;
+	String message="message";
+	Throwable throwable=null;
+	Object[] argArray=null;
+	LoggingEvent event=new LoggingEvent(fqcn, logger, level, message, throwable, argArray);
+	checkSerialization(event);
+  }
+
+  public void testSimpleSerializeSetter() throws IOException, ClassNotFoundException {
+    Level level= Level.DEBUG;
+    String message="message";
+    Object[] argArray=null;
+
+    LoggingEvent event=new LoggingEvent();
+    event.setLevel(level);
+    event.setArgumentArray(argArray);
+    event.setMessage(message);
+
+    checkSerialization(event);
+  }
+
+  public void testSerializeThrowable() throws IOException, ClassNotFoundException {
+	String fqcn="fqcn";
+	Level level= Level.DEBUG;
+	String message="message";
+	Throwable throwable=new Throwable("Throw!");
+	Object[] argArray=null;
+	LoggingEvent event=new LoggingEvent(fqcn, logger, level, message, throwable, argArray);
+	checkSerialization(event);
+  }
+
+	public void testSerializeArgs() throws IOException, ClassNotFoundException {
+	  String fqcn="fqcn";
+	  Level level= Level.DEBUG;
+	  String message="message {} {} {}";
+	  Throwable throwable=new Throwable("Throw!");
+	  Object[] argArray=new Object[]{"Serializable", new NotSerializable(), null};
+	  LoggingEvent event=new LoggingEvent(fqcn, logger, level, message, throwable, argArray);
+	  LoggingEvent readEvent = checkSerialization(event);
+	  assertEquals("message Serializable NotSerializable! null", readEvent.getFormattedMessage());
+	}
+
+	public void testSerializeLargeArgs() throws IOException, ClassNotFoundException {
+	  String fqcn="fqcn";
+	  Level level= Level.DEBUG;
+	  String message="message {} {} {}";
+	  Throwable throwable=new Throwable("Throw!");
+	  StringBuffer buffer=new StringBuffer();
+	  for(int i=0;i<100000;i++) {
+		  buffer.append("X");
+	  }
+	  String largeString=buffer.toString();
+	  Object[] argArray=new Object[]{"Serializable", new NotSerializable(), largeString};
+	  LoggingEvent event=new LoggingEvent(fqcn, logger, level, message, throwable, argArray);
+	  LoggingEvent readEvent = checkSerialization(event);
+	  assertEquals("message Serializable NotSerializable! "+largeString, readEvent.getFormattedMessage());
+	}
+
+  public void testSerializeArgsSetter() throws IOException, ClassNotFoundException {
+    Level level= Level.DEBUG;
+    String message="message {} {} {}";
+    Object[] argArray=new Object[]{"Serializable", new NotSerializable(), null};
+
+    LoggingEvent event=new LoggingEvent();
+    event.setLevel(level);
+    event.setArgumentArray(argArray);
+    event.setMessage(message);
+    assertEquals("message Serializable NotSerializable! null", event.getFormattedMessage());
+
+    LoggingEvent readEvent = checkSerialization(event);
+    assertEquals("message Serializable NotSerializable! null", readEvent.getFormattedMessage());
+  }
+
+  private LoggingEvent checkSerialization(LoggingEvent event) throws IOException, ClassNotFoundException {
+	ByteArrayOutputStream bos=new ByteArrayOutputStream();
+	ObjectOutputStream oos=new ObjectOutputStream(bos);
+	oos.writeObject(event);
+	oos.close();
+	ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
+	ObjectInputStream ois=new ObjectInputStream(bis);
+	LoggingEvent readEvent=(LoggingEvent) ois.readObject();
+	ois.close();
+	assertEquals(event.getLevel(), readEvent.getLevel());
+	assertEquals(event.getFormattedMessage(), readEvent.getFormattedMessage());
+	assertEquals(event.getMessage(), readEvent.getMessage());
+	// arguments that are not Serializable are already substituted by Strings
+	assertTrue(Arrays.equals(event.getArgumentArray(), readEvent.getArgumentArray()));
+	// ThrowableInformation does not implement equals/hashCode (yet?)
+	//assertEquals(event.getThrowableInformation(), readEvent.getThrowableInformation());
+	return readEvent;
+  }
+
+  private static class NotSerializable {
+	public String toString() {
+	  return "NotSerializable!";
+	}
+  }
+}