Log objects directly.

src/main/java/org/fluentd/logger/FluentLogger.java

@@ -82,10 +82,18 @@ public boolean log(String tag, String key, Object value, long timestamp) {
     }
 
     public boolean log(String tag, Map<String, Object> data) {
-        return log(tag, data, 0);
+        return log(tag, (Object)data, 0);
     }
 
     public boolean log(String tag, Map<String, Object> data, long timestamp) {
+        return log(tag, (Object)data, timestamp);
+    }
+
+    public boolean log(String tag, Object data) {
+        return log(tag, data, 0);
+    }
+
+    public boolean log(String tag, Object data, long timestamp) {
         String concatTag = null;
         if (tagPrefix == null || tagPrefix.length() == 0) {
             concatTag = tag;

src/main/java/org/fluentd/logger/sender/DefaultEventTemplate.java

@@ -0,0 +1,12 @@
+package org.fluentd.logger.sender;
+
+import java.io.IOException;
+
+import org.msgpack.packer.Packer;
+
+public class DefaultEventTemplate extends EventTemplate {
+    @Override
+    protected void doWriteData(Packer pk, Object data, boolean required) throws IOException {
+        pk.write(data);
+    }
+}

src/main/java/org/fluentd/logger/sender/Event.java

@@ -17,30 +17,22 @@
 //
 package org.fluentd.logger.sender;
 
-import java.io.IOException;
-import java.util.Map;
-
-import org.msgpack.MessageTypeException;
-import org.msgpack.packer.Packer;
-import org.msgpack.template.AbstractTemplate;
-import org.msgpack.template.Templates;
-import org.msgpack.unpacker.Unpacker;
 
 public class Event {
     public String tag;
 
     public long timestamp;
 
-    public Map<String, Object> data;
+    public Object data;
 
     public Event() {
     }
 
-    public Event(String tag, Map<String, Object> data) {
+    public Event(String tag, Object data) {
         this(tag, System.currentTimeMillis() / 1000, data);
     }
 
-    public Event(String tag, long timestamp, Map<String, Object> data) {
+    public Event(String tag, long timestamp, Object data) {
         this.tag = tag;
         this.timestamp = timestamp;
         this.data = data;
@@ -51,42 +43,4 @@ public String toString() {
         return String.format("Event{tag=%s,timestamp=%d,data=%s}",
                 tag, timestamp, data.toString());
     }
-
-    public static class EventTemplate extends AbstractTemplate<Event> {
-        public static EventTemplate INSTANCE = new EventTemplate();
-
-        public void write(Packer pk, Event v, boolean required) throws IOException {
-            if (v == null) {
-                if (required) {
-                    throw new MessageTypeException("Attempted to write null");
-                }
-                pk.writeNil();
-                return;
-            }
-
-            pk.writeArrayBegin(3);
-            {
-                Templates.TString.write(pk, v.tag, required);
-                Templates.TLong.write(pk, v.timestamp, required);
-                pk.writeMapBegin(v.data.size());
-                {
-                    for (Map.Entry<String, Object> entry : v.data.entrySet()) {
-                        Templates.TString.write(pk, entry.getKey(), required);
-                        try {
-                            pk.write(entry.getValue());
-                        } catch (MessageTypeException e) {
-                            String val = entry.getValue().toString();
-                            Templates.TString.write(pk, val, required);
-                        }
-                    }
-                }
-                pk.writeMapEnd();
-            }
-            pk.writeArrayEnd();
-        }
-
-        public Event read(Unpacker u, Event to, boolean required) throws IOException {
-            throw new UnsupportedOperationException("Don't need the operation");
-        }
-    }
 }

src/main/java/org/fluentd/logger/sender/EventTemplate.java

@@ -0,0 +1,38 @@
+package org.fluentd.logger.sender;
+
+import java.io.IOException;
+
+import org.msgpack.MessageTypeException;
+import org.msgpack.packer.Packer;
+import org.msgpack.template.AbstractTemplate;
+import org.msgpack.template.Templates;
+import org.msgpack.unpacker.Unpacker;
+
+public abstract class EventTemplate extends AbstractTemplate<Event> {
+    public static EventTemplate INSTANCE = new DefaultEventTemplate();
+
+    public void write(Packer pk, Event v, boolean required) throws IOException {
+        if (v == null) {
+            if (required) {
+                throw new MessageTypeException("Attempted to write null");
+            }
+            pk.writeNil();
+            return;
+        }
+
+        pk.writeArrayBegin(3);
+        {
+            Templates.TString.write(pk, v.tag, required);
+            Templates.TLong.write(pk, v.timestamp, required);
+            doWriteData(pk, v.data, required);
+        }
+        pk.writeArrayEnd();
+    }
+
+    protected abstract void doWriteData(Packer pk, Object data, boolean required)
+    throws IOException;
+
+    public Event read(Unpacker u, Event to, boolean required) throws IOException {
+        throw new UnsupportedOperationException("Don't need the operation");
+    }
+}

src/main/java/org/fluentd/logger/sender/MapStyleEventTemplate.java

@@ -0,0 +1,75 @@
+package org.fluentd.logger.sender;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.msgpack.MessageTypeException;
+import org.msgpack.packer.Packer;
+import org.msgpack.template.Templates;
+
+public class MapStyleEventTemplate extends EventTemplate {
+    @Override
+    protected void doWriteData(Packer pk, Object data, boolean required) throws IOException {
+        if(data instanceof Map){
+            writeMap(pk, (Map<?, ?>)data, required);
+        } else{
+            try{
+                pk.write(data);
+            } catch (MessageTypeException e) {
+                writeObj(pk, data, required);
+            }
+        }
+    }
+
+    private <K, V> void writeMap(Packer pk, Map<K, V> map, boolean required) throws IOException {
+        pk.writeMapBegin(map.size());
+        {
+            for (Map.Entry<?, ?> entry : map.entrySet()) {
+                Templates.TString.write(pk, entry.getKey().toString(), required);
+                Object value = entry.getValue();
+                if(value instanceof Map<?, ?>){
+                    writeMap(pk, (Map<?, ?>)value, required);
+                } else{
+                    try {
+                        pk.write(entry.getValue());
+                    } catch (MessageTypeException e) {
+                        writeObj(pk, entry.getValue(), required);
+                    }
+                }
+            }
+        }
+        pk.writeMapEnd();
+    }
+
+    private void writeObj(Packer pk, Object data, boolean required) throws IOException {
+        Map<String, Object> map = new LinkedHashMap<String, Object>();
+        Class<?> clazz = data.getClass();
+        while(!clazz.equals(Object.class)){
+            for(Method m : clazz.getDeclaredMethods()){
+                if(m.getDeclaringClass().equals(Object.class)) continue;
+                if(m.getParameterTypes().length != 0) continue;
+                String name = null;
+                if(m.getName().startsWith("get")){
+                    name = m.getName().substring(3);
+                } else if(m.getName().startsWith("is") && m.getReturnType().equals(boolean.class)){
+                    name = m.getName().substring(2);
+                } else{
+                    continue;
+                }
+                if(name.length() == 0) continue;
+                name = name.substring(0, 1).toLowerCase() + (name.length() == 1 ? "" : name.substring(1));
+                try {
+                    map.put(name, m.invoke(data));
+                } catch (IllegalArgumentException e) {
+                } catch (IllegalAccessException e) {
+                } catch (InvocationTargetException e) {
+                }
+            }
+            clazz = clazz.getSuperclass();
+        }
+        writeMap(pk, map, required);
+    }
+}

src/main/java/org/fluentd/logger/sender/NullSender.java

@@ -17,20 +17,19 @@
 //
 package org.fluentd.logger.sender;
 
-import java.util.Map;
 
 public class NullSender implements Sender {
 
     public NullSender(String host, int port, int timeout, int bufferCapacity) {
     }
 
     @Override
-    public boolean emit(String tag, Map<String, Object> data) {
+    public boolean emit(String tag, Object data) {
         return emit(tag, System.currentTimeMillis() / 1000, data);
     }
 
     @Override
-    public boolean emit(String tag, long timestamp, Map<String, Object> data) {
+    public boolean emit(String tag, long timestamp, Object data) {
         return true;
     }
 

src/main/java/org/fluentd/logger/sender/RawSocketSender.java

@@ -23,7 +23,6 @@
 import java.net.Socket;
 import java.net.SocketAddress;
 import java.nio.ByteBuffer;
-import java.util.Map;
 import java.util.logging.Level;
 
 import org.msgpack.MessagePack;
@@ -63,7 +62,7 @@ public RawSocketSender(String host, int port, int timeout, int bufferCapacity) {
 
     public RawSocketSender(String host, int port, int timeout, int bufferCapacity, Reconnector reconnector) {
         msgpack = new MessagePack();
-        msgpack.register(Event.class, Event.EventTemplate.INSTANCE);
+        msgpack.register(Event.class, EventTemplate.INSTANCE);
         pendings = ByteBuffer.allocate(bufferCapacity);
         server = new InetSocketAddress(host, port);
         this.reconnector = reconnector;
@@ -125,11 +124,11 @@ public void close() {
         }
     }
 
-    public boolean emit(String tag, Map<String, Object> data) {
+    public boolean emit(String tag, Object data) {
         return emit(tag, System.currentTimeMillis() / 1000, data);
     }
 
-    public boolean emit(String tag, long timestamp, Map<String, Object> data) {
+    public boolean emit(String tag, long timestamp, Object data) {
         return emit(new Event(tag, timestamp, data));
     }
 

src/main/java/org/fluentd/logger/sender/Sender.java

@@ -17,12 +17,10 @@
 //
 package org.fluentd.logger.sender;
 
-import java.util.Map;
-
 public interface Sender {
-    boolean emit(String tag, Map<String, Object> data);
+    boolean emit(String tag, Object data);
 
-    boolean emit(String tag, long timestamp, Map<String, Object> data);
+    boolean emit(String tag, long timestamp, Object data);
 
     void flush();