diff --git a/frodo-android-sample/build.gradle b/frodo-android-sample/build.gradle
index c221402..c19cbaf 100644
--- a/frodo-android-sample/build.gradle
+++ b/frodo-android-sample/build.gradle
@@ -56,6 +56,6 @@ android {
 }
 
 dependencies {
-  compile 'io.reactivex:rxjava:1.0.14'
-  compile 'io.reactivex:rxandroid:0.25.0'
+  compile 'io.reactivex:rxjava:1.2.6'
+  compile 'io.reactivex:rxandroid:1.2.1'
 }
diff --git a/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/DataPresenter.java b/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/DataPresenter.java
deleted file mode 100644
index f609cc1..0000000
--- a/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/DataPresenter.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package com.fernandocejas.example.frodo;
-
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-
-public class DataPresenter {
-
-  public void getData() {
-    sleep(5);
-  }
-
-  public void getData(String name) {
-    sleep(5);
-  }
-
-  public void getData(String name, int quantity) {
-    sleep(5);
-  }
-
-  public void getData(String name, int quantity, int count) {
-    sleep(5);
-  }
-
-  public void printMessage(String tag, String message) {
-    sleep(10);
-  }
-
-  public void anotherMethodOne() {
-    sleep(25);
-  }
-
-  public void anotherMethodTwo() {
-    sleep(18);
-  }
-
-  private void sleep(long millis) {
-    try {
-      Thread.sleep(millis);
-    } catch (InterruptedException e) {
-      e.printStackTrace();
-    }
-  }
-
-  public void executeDiskIOTaskOnUiThread() {
-    try {
-      File file = File.createTempFile("test", ".txt");
-      FileWriter writer = new FileWriter(file);
-      writer.write("This is Fernando Cejas testing something");
-      writer.close();
-    } catch (IOException e) {
-      e.printStackTrace();
-    } finally {
-    }
-  }
-}
diff --git a/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/SamplesActivity.java b/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/SamplesActivity.java
index ce259f9..5d5c1a4 100644
--- a/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/SamplesActivity.java
+++ b/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/SamplesActivity.java
@@ -5,11 +5,15 @@
 import android.view.View;
 import android.widget.Button;
 import android.widget.Toast;
+
 import com.fernandocejas.example.frodo.sample.MySubscriber;
 import com.fernandocejas.example.frodo.sample.MySubscriberBackpressure;
 import com.fernandocejas.example.frodo.sample.MySubscriberVoid;
 import com.fernandocejas.example.frodo.sample.ObservableSample;
+import com.fernandocejas.example.frodo.sample.SingleSample;
+
 import java.util.List;
+
 import rx.Subscriber;
 import rx.android.schedulers.AndroidSchedulers;
 import rx.functions.Action1;
@@ -18,6 +22,7 @@
 public class SamplesActivity extends Activity {
 
   private Button btnRxLogObservable;
+  private Button btnRxLogSingle;
   private Button btnRxLogSubscriber;
 
   private View.OnClickListener rxLogObservableListener = new View.OnClickListener() {
@@ -26,74 +31,134 @@ public void onClick(View v) {
       ObservableSample observableSample = new ObservableSample();
 
       observableSample.stringItemWithDefer()
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe();
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe();
 
       observableSample.numbers()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new Action1<Integer>() {
-            @Override
-            public void call(Integer integer) {
-              toastMessage("onNext() Integer--> " + String.valueOf(integer));
-            }
-          });
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new Action1<Integer>() {
+                @Override
+                public void call(Integer integer) {
+                  toastMessage("onNext() Integer--> " + String.valueOf(integer));
+                }
+              });
 
       observableSample.moreNumbers().toList().toBlocking().single();
 
       observableSample.names()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new Action1<String>() {
-            @Override
-            public void call(String string) {
-              toastMessage("onNext() String--> " + string);
-            }
-          });
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new Action1<String>() {
+                @Override
+                public void call(String string) {
+                  toastMessage("onNext() String--> " + string);
+                }
+              });
 
       observableSample.error()
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new Subscriber<String>() {
-            @Override
-            public void onCompleted() {
-              //nothing here
-            }
-
-            @Override
-            public void onError(Throwable e) {
-              toastMessage("onError() --> " + e.getMessage());
-            }
-
-            @Override
-            public void onNext(String s) {
-              //nothing here
-            }
-          });
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new Subscriber<String>() {
+                @Override
+                public void onCompleted() {
+                  //nothing here
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                  toastMessage("onError() --> " + e.getMessage());
+                }
+
+                @Override
+                public void onNext(String s) {
+                  //nothing here
+                }
+              });
 
       observableSample.list()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new Action1<List<ObservableSample.MyDummyClass>>() {
-            @Override
-            public void call(List<ObservableSample.MyDummyClass> myDummyClasses) {
-              toastMessage("onNext() List--> " + myDummyClasses.toString());
-            }
-          });
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new Action1<List<ObservableSample.MyDummyClass>>() {
+                @Override
+                public void call(List<ObservableSample.MyDummyClass> myDummyClasses) {
+                  toastMessage("onNext() List--> " + myDummyClasses.toString());
+                }
+              });
 
       observableSample.doNothing()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe();
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe();
 
       observableSample.doSomething(v)
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe();
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe();
 
       observableSample.sendNull()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe();
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe();
+    }
+  };
+
+  private View.OnClickListener rxLogSingleListener = new View.OnClickListener() {
+    @Override
+    public void onClick(View v) {
+      SingleSample singleSample = new SingleSample();
+
+      singleSample.stringItemWithDefer()
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe();
+
+      singleSample.numbers()
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new Action1<Integer>() {
+                @Override
+                public void call(Integer integer) {
+                  toastMessage("onNext() Integer--> " + String.valueOf(integer));
+                }
+              });
+
+      singleSample.error()
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new Subscriber<String>() {
+                @Override
+                public void onCompleted() {
+                  //nothing here
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                  toastMessage("onError() --> " + e.getMessage());
+                }
+
+                @Override
+                public void onNext(String s) {
+                  //nothing here
+                }
+              });
+
+      singleSample.list()
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new Action1<List<SingleSample.MyDummyClass>>() {
+                @Override
+                public void call(List<SingleSample.MyDummyClass> myDummyClasses) {
+                  toastMessage("onNext() List--> " + myDummyClasses.toString());
+                }
+              });
+
+      singleSample.doSomething(v)
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe();
+
+      singleSample.sendNull()
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe();
     }
   };
 
@@ -104,35 +169,35 @@ public void onClick(View v) {
       toastMessage("Subscribing to observables...Check logcat output...");
 
       observableSample.strings()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new MySubscriber());
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new MySubscriber());
 
       observableSample.stringsWithError()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new MySubscriber());
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new MySubscriber());
 
       observableSample.numbersBackpressure()
-          .onBackpressureDrop()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new MySubscriberBackpressure());
+              .onBackpressureDrop()
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new MySubscriberBackpressure());
 
       observableSample.doNothing()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new MySubscriberVoid());
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new MySubscriberVoid());
 
       observableSample.doSomething(v)
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new MySubscriberVoid());
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new MySubscriberVoid());
 
       observableSample.sendNull()
-          .subscribeOn(Schedulers.newThread())
-          .observeOn(AndroidSchedulers.mainThread())
-          .subscribe(new MySubscriber());
+              .subscribeOn(Schedulers.newThread())
+              .observeOn(AndroidSchedulers.mainThread())
+              .subscribe(new MySubscriber());
     }
   };
 
@@ -145,9 +210,11 @@ protected void onCreate(Bundle savedInstanceState) {
 
   private void mapGUI() {
     this.btnRxLogObservable = (Button) findViewById(R.id.btnRxLogObservable);
+    this.btnRxLogSingle = (Button) findViewById(R.id.btnRxLogSingle);
     this.btnRxLogSubscriber = (Button) findViewById(R.id.btnRxLogSubscriber);
 
     this.btnRxLogObservable.setOnClickListener(rxLogObservableListener);
+    this.btnRxLogSingle.setOnClickListener(rxLogSingleListener);
     this.btnRxLogSubscriber.setOnClickListener(rxLogSubscriberListener);
   }
 
diff --git a/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/sample/SingleSample.java b/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/sample/SingleSample.java
new file mode 100644
index 0000000..f10cee2
--- /dev/null
+++ b/frodo-android-sample/src/main/java/com/fernandocejas/example/frodo/sample/SingleSample.java
@@ -0,0 +1,89 @@
+package com.fernandocejas.example.frodo.sample;
+
+import android.view.View;
+
+import com.fernandocejas.frodo.annotation.RxLogSingle;
+
+import java.util.Arrays;
+import java.util.List;
+
+import rx.Single;
+import rx.SingleSubscriber;
+import rx.functions.Func0;
+import rx.schedulers.Schedulers;
+
+import static com.fernandocejas.frodo.annotation.RxLogSingle.Scope.EVENTS;
+import static com.fernandocejas.frodo.annotation.RxLogSingle.Scope.EVERYTHING;
+import static com.fernandocejas.frodo.annotation.RxLogSingle.Scope.NOTHING;
+import static com.fernandocejas.frodo.annotation.RxLogSingle.Scope.SCHEDULERS;
+
+public class SingleSample {
+  public SingleSample() {
+  }
+
+  @RxLogSingle(EVERYTHING)
+  public Single<Integer> numbers() {
+    return Single.just(1);
+  }
+
+  @RxLogSingle
+  public Single<String> error() {
+    return Single.error(new IllegalArgumentException("My error"));
+  }
+
+  @RxLogSingle(SCHEDULERS)
+  public Single<List<MyDummyClass>> list() {
+    return Single.just(buildDummyList());
+  }
+
+  @RxLogSingle(EVENTS)
+  public Single<String> stringItemWithDefer() {
+    return Single.defer(new Func0<Single<String>>() {
+      @Override
+      public Single<String> call() {
+        return Single.create(new Single.OnSubscribe<String>() {
+          @Override
+          public void call(SingleSubscriber<? super String> singleSubscriber) {
+            try {
+              singleSubscriber.onSuccess("String item Three");
+            } catch (Exception e) {
+              singleSubscriber.onError(e);
+            }
+          }
+        }).subscribeOn(Schedulers.computation());
+      }
+    });
+  }
+
+  /**
+   * Nothing should happen here when annotating this method with {@link RxLogSingle}
+   * because it does not returns an {@link Single}.
+   */
+  @RxLogSingle(NOTHING)
+  public List<MyDummyClass> buildDummyList() {
+    return Arrays.asList(new MyDummyClass("Batman"), new MyDummyClass("Superman"));
+  }
+
+  @RxLogSingle
+  public Single<Void> doSomething(View view) {
+    return Single.just(null);
+  }
+
+  @RxLogSingle
+  public Single<String> sendNull() {
+    return Single.just(null);
+  }
+
+  public static final class MyDummyClass {
+    private final String name;
+
+    MyDummyClass(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return "Name: " + name;
+    }
+  }
+}
diff --git a/frodo-android-sample/src/main/res/layout/activity_samples.xml b/frodo-android-sample/src/main/res/layout/activity_samples.xml
index cc819fe..5e6ec73 100644
--- a/frodo-android-sample/src/main/res/layout/activity_samples.xml
+++ b/frodo-android-sample/src/main/res/layout/activity_samples.xml
@@ -34,6 +34,12 @@
       android:layout_marginBottom="@dimen/button_vertical_margin"
       android:text="@string/btn_text_sample_rx_log_observable"
       />
+  <Button
+      android:id="@+id/btnRxLogSingle"
+      style="@style/AppButton"
+      android:layout_marginBottom="@dimen/button_vertical_margin"
+      android:text="@string/btn_text_sample_rx_log_single"
+      />
 
   <Button
       android:id="@+id/btnRxLogSubscriber"
diff --git a/frodo-android-sample/src/main/res/values/strings.xml b/frodo-android-sample/src/main/res/values/strings.xml
index 7359f64..b2cd1a6 100644
--- a/frodo-android-sample/src/main/res/values/strings.xml
+++ b/frodo-android-sample/src/main/res/values/strings.xml
@@ -8,6 +8,7 @@
 
   <string name="btn_text_load_examples">Load Frodo Samples</string>
   <string name="btn_text_sample_rx_log_observable">Rx Log Observable</string>
+  <string name="btn_text_sample_rx_log_single">Rx Log Single</string>
   <string name="btn_text_sample_rx_log_subscriber">Rx Log Subscriber</string>
 
   <string name="string_tip_logcat">Do not forget to check the logcat to see the samples in action</string>
diff --git a/frodo-api/src/main/java/com/fernandocejas/frodo/annotation/RxLogSingle.java b/frodo-api/src/main/java/com/fernandocejas/frodo/annotation/RxLogSingle.java
new file mode 100644
index 0000000..d0bbb19
--- /dev/null
+++ b/frodo-api/src/main/java/com/fernandocejas/frodo/annotation/RxLogSingle.java
@@ -0,0 +1,38 @@
+package com.fernandocejas.frodo.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * <br>Annotated methods which return rx.Singles will print the following information on
+ * android logcat when emitting items.
+ * A {@link Scope} option can be passed to choose different logging scopes.<br>
+ *
+ * <br>OUTPUT EXAMPLE:<br>
+ *
+ * <br>Frodo => [@Single :: @InClass -> SingleSample :: @Method -> names()]
+ * <br>Frodo => [@Single#names -> onSubscribe()]
+ * <br>Frodo => [@Single#names -> onSuccess() -> Fernando :: @Time -> 1 ms]
+ * <br>Frodo => [@Single#names -> @SubscribeOn -> RxNewThreadScheduler-8 :: @ObserveOn -> main]
+ * <br>Frodo => [@Single#names -> onUnsubscribe()]<br>
+ *
+ * @see <a href="https://github.com/android10/frodo/wiki">Frodo Documentation</a>
+ */
+@Retention(RUNTIME)
+@Target({ METHOD })
+public @interface RxLogSingle {
+  Scope value() default Scope.EVERYTHING;
+
+  /**
+   * Logging scope of the current annotated rx.Single.<br>
+   *
+   * <li>{@link #EVERYTHING}: Logs stream data, schedulers and rx.Single events. Default.</li>
+   * <li>{@link #SCHEDULERS}: Logs schedulers where the annotated rx.Single operates on.</li>
+   * <li>{@link #EVENTS}: Logs rx.Single events only.</li>
+   * <li>{@link #NOTHING}: Turns off logging for the annotated rx.Single.</li>
+   */
+  enum Scope { EVERYTHING, SCHEDULERS, EVENTS, NOTHING }
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogObservable.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogObservable.java
index cc2755d..5f103b1 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogObservable.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogObservable.java
@@ -3,7 +3,7 @@
 import com.fernandocejas.frodo.annotation.RxLogObservable;
 import com.fernandocejas.frodo.internal.observable.FrodoObservable;
 import com.fernandocejas.frodo.internal.observable.LoggableObservableFactory;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.internal.observable.ObservableInfo;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 import java.lang.annotation.Annotation;
@@ -30,7 +30,7 @@ public static boolean methodAnnotatedWithRxLogObservable(ProceedingJoinPoint joi
   @Around("methodAnnotatedWithRxLogObservable(joinPoint)")
   public Object weaveAroundJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
     final FrodoProceedingJoinPoint proceedingJoinPoint = new FrodoProceedingJoinPoint(joinPoint);
-    final MessageManager messageManager = new MessageManager();
+    final ObservableMessageManager messageManager = new ObservableMessageManager();
     final LoggableObservableFactory observableFactory =
         new LoggableObservableFactory(proceedingJoinPoint, messageManager,
             new ObservableInfo(proceedingJoinPoint));
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogSingle.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogSingle.java
new file mode 100644
index 0000000..053f970
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogSingle.java
@@ -0,0 +1,44 @@
+package com.fernandocejas.frodo.aspect;
+
+import com.fernandocejas.frodo.annotation.RxLogSingle;
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.internal.single.FrodoSingle;
+import com.fernandocejas.frodo.internal.single.LoggableSingleFactory;
+import com.fernandocejas.frodo.internal.single.SingleInfo;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.aspectj.lang.reflect.MethodSignature;
+
+import java.lang.annotation.Annotation;
+
+import rx.Single;
+
+@Aspect
+public class LogSingle {
+  private static final String METHOD =
+      "execution(@com.fernandocejas.frodo.annotation.RxLogSingle * *(..)) && if()";
+
+  @Pointcut(METHOD)
+  public static boolean methodAnnotatedWithRxLogSingle(ProceedingJoinPoint joinPoint) {
+    final FrodoProceedingJoinPoint frodoJoinPoint = new FrodoProceedingJoinPoint(joinPoint);
+    final Annotation annotation = frodoJoinPoint.getAnnotation(RxLogSingle.class);
+    return ((MethodSignature) joinPoint.getSignature()).getReturnType() == Single.class
+        && ((RxLogSingle) annotation).value() != RxLogSingle.Scope.NOTHING;
+  }
+
+  @Around("methodAnnotatedWithRxLogSingle(joinPoint)")
+  public Object weaveAroundJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
+    final FrodoProceedingJoinPoint proceedingJoinPoint = new FrodoProceedingJoinPoint(joinPoint);
+    final SingleMessageManager messageManager = new SingleMessageManager();
+    final LoggableSingleFactory observableFactory =
+        new LoggableSingleFactory(proceedingJoinPoint, messageManager,
+            new SingleInfo(proceedingJoinPoint));
+
+    return new FrodoSingle(proceedingJoinPoint, messageManager,
+        observableFactory).getSingle();
+  }
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogSubscriber.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogSubscriber.java
index 71504bd..0d22829 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogSubscriber.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/aspect/LogSubscriber.java
@@ -1,14 +1,16 @@
 package com.fernandocejas.frodo.aspect;
 
 import com.fernandocejas.frodo.internal.Counter;
-import com.fernandocejas.frodo.internal.MessageManager;
 import com.fernandocejas.frodo.internal.StopWatch;
+import com.fernandocejas.frodo.internal.messenger.SubscriberMessageManager;
 import com.fernandocejas.frodo.joinpoint.FrodoJoinPoint;
+
 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.annotation.After;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Before;
 import org.aspectj.lang.annotation.Pointcut;
+
 import rx.Subscriber;
 
 @Aspect
@@ -27,14 +29,14 @@ public class LogSubscriber {
 
   private final Counter counter;
   private final StopWatch stopWatch;
-  private final MessageManager messageManager;
+  private final SubscriberMessageManager messageManager;
   private boolean isFirstElementEmitted = true;
 
   public LogSubscriber() {
-    this(new Counter(), new StopWatch(), new MessageManager());
+    this(new Counter(), new StopWatch(), new SubscriberMessageManager());
   }
 
-  public LogSubscriber(Counter counter, StopWatch stopWatch, MessageManager messageManager) {
+  public LogSubscriber(Counter counter, StopWatch stopWatch, SubscriberMessageManager messageManager) {
     this.counter = counter;
     this.stopWatch = stopWatch;
     this.messageManager = messageManager;
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/StopWatch.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/StopWatch.java
index 77dd93d..1919ac6 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/StopWatch.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/StopWatch.java
@@ -35,6 +35,12 @@ public void stop() {
   }
 
   public long getTotalTimeMillis() {
-    return (elapsedTime != 0) ? TimeUnit.NANOSECONDS.toMillis(endTime - startTime) : 0;
+    return (elapsedTime != 0) ? minimumMillis() : 0;
+  }
+
+  private long minimumMillis() {
+    long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
+    // sanity for tests where calculations take <1 millisecond
+    return millis == 0 ? 1 : millis;
   }
 }
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/DebugLog.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/DebugLog.java
similarity index 79%
rename from frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/DebugLog.java
rename to frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/DebugLog.java
index 39f80ec..d63c62a 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/DebugLog.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/DebugLog.java
@@ -1,4 +1,4 @@
-package com.fernandocejas.frodo.internal;
+package com.fernandocejas.frodo.internal.messenger;
 
 import android.util.Log;
 
@@ -17,7 +17,7 @@ class DebugLog {
    * call occurs.
    * @param message The message you would like logged.
    */
-  public void log(String tag, String message) {
+  void log(String tag, String message) {
     Log.d(tag, message);
   }
 }
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/MessengerBuilder.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/MessengerBuilder.java
new file mode 100644
index 0000000..39199e5
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/MessengerBuilder.java
@@ -0,0 +1,24 @@
+package com.fernandocejas.frodo.internal.messenger;
+
+abstract class MessengerBuilder {
+  static final String LOG_START = "@";
+  static final String SEPARATOR = " :: ";
+  static final String METHOD_SEPARATOR = "#";
+  static final String VALUE_SEPARATOR = " -> ";
+  static final String TEXT_ENCLOSING_SYMBOL = "'";
+  static final String LOG_ENCLOSING_OPEN = "[";
+  static final String LOG_ENCLOSING_CLOSE = "]";
+  static final String LIBRARY_LABEL = "Frodo => ";
+  static final String CLASS_LABEL = LOG_START + "InClass" + VALUE_SEPARATOR;
+  static final String METHOD_LABEL = LOG_START + "Method" + VALUE_SEPARATOR;
+  static final String TIME_LABEL = LOG_START + "Time" + VALUE_SEPARATOR;
+  static final String TIME_MILLIS = " ms";
+  static final String EMITTED_ELEMENTS_LABEL = LOG_START + "Emitted" + VALUE_SEPARATOR;
+  static final String LABEL_ELEMENT_SINGULAR = " element";
+  static final String LABEL_ELEMENT_PLURAL = " elements";
+
+  static final String LABEL_SUBSCRIBER_SUBSCRIBE_ON =
+          LOG_START + "SubscribeOn" + VALUE_SEPARATOR;
+  static final String LABEL_SUBSCRIBER_OBSERVE_ON =
+          LOG_START + "ObserveOn" + VALUE_SEPARATOR;
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/MessageBuilder.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/ObservableMessageBuilder.java
similarity index 55%
rename from frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/MessageBuilder.java
rename to frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/ObservableMessageBuilder.java
index a4cf423..6ad0afc 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/MessageBuilder.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/ObservableMessageBuilder.java
@@ -1,52 +1,26 @@
-package com.fernandocejas.frodo.internal;
+package com.fernandocejas.frodo.internal.messenger;
 
 import com.fernandocejas.frodo.core.optional.Optional;
 import com.fernandocejas.frodo.internal.observable.ObservableInfo;
 import com.fernandocejas.frodo.joinpoint.FrodoJoinPoint;
+
 import java.util.List;
 
 /**
  * Class used to build different messages that will be shown in debug mode
  */
-class MessageBuilder {
+class ObservableMessageBuilder extends MessengerBuilder {
 
-  private static final String LOG_START = "@";
-  private static final String SEPARATOR = " :: ";
-  private static final String METHOD_SEPARATOR = "#";
-  private static final String VALUE_SEPARATOR = " -> ";
-  private static final String TEXT_ENCLOSING_SYMBOL = "'";
-  private static final String LOG_ENCLOSING_OPEN = "[";
-  private static final String LOG_ENCLOSING_CLOSE = "]";
-  private static final String LIBRARY_LABEL = "Frodo => ";
-  private static final String CLASS_LABEL = LOG_START + "InClass" + VALUE_SEPARATOR;
-  private static final String METHOD_LABEL = LOG_START + "Method" + VALUE_SEPARATOR;
-  private static final String TIME_LABEL = LOG_START + "Time" + VALUE_SEPARATOR;
-  private static final String TIME_MILLIS = " ms";
   private static final String OBSERVABLE_LABEL = LOG_START + "Observable";
-  private static final String EMITTED_ELEMENTS_LABEL = LOG_START + "Emitted" + VALUE_SEPARATOR;
   private static final String LABEL_OBSERVABLE_ON_SUBSCRIBE = "onSubscribe()";
   private static final String LABEL_OBSERVABLE_ON_NEXT = "onNext()";
   private static final String LABEL_OBSERVABLE_ON_ERROR = "onError()";
   private static final String LABEL_OBSERVABLE_ON_COMPLETED = "onCompleted()";
   private static final String LABEL_OBSERVABLE_ON_TERMINATE = "onTerminate()";
   private static final String LABEL_OBSERVABLE_ON_UNSUBSCRIBE = "onUnsubscribe()";
-  private static final String LABEL_OBSERVABLE_SUBSCRIBE_ON =
-      LOG_START + "SubscribeOn" + VALUE_SEPARATOR;
-  private static final String SUBSCRIBER_LABEL = LOG_START + "Subscriber";
-  private static final String LABEL_SUBSCRIBER_ON_START = "onStart()";
-  private static final String LABEL_SUBSCRIBER_ON_NEXT = "onNext()";
-  private static final String LABEL_SUBSCRIBER_ON_ERROR = "onError()";
-  private static final String LABEL_SUBSCRIBER_ON_COMPLETED = "onCompleted()";
-  private static final String LABEL_SUBSCRIBER_UN_SUBSCRIBE = "unSubscribe()";
-  private static final String LABEL_SUBSCRIBER_OBSERVE_ON =
-      LOG_START + "ObserveOn" + VALUE_SEPARATOR;
-  private static final String REQUESTED_ELEMENTS_LABEL = LOG_START + "Requested" + VALUE_SEPARATOR;
-  private static final String RECEIVED_ELEMENTS_LABEL = LOG_START + "Received" + VALUE_SEPARATOR;
-  private static final String LABEL_ELEMENT_SINGULAR = " element";
-  private static final String LABEL_ELEMENT_PLURAL = " elements";
-  private static final String LABEL_MESSAGE_NULL_OBSERVABLES = "You received a null observable";
 
-  MessageBuilder() {}
+  ObservableMessageBuilder() {
+  }
 
   String buildObservableInfoMessage(ObservableInfo observableInfo) {
     final FrodoJoinPoint joinPoint = observableInfo.getJoinPoint();
@@ -146,99 +120,6 @@ String buildObservableOnUnsubscribeMessage(ObservableInfo observableInfo) {
     return message.toString();
   }
 
-  String buildSubscriberOnStartMessage(String subscriberName) {
-    final StringBuilder message = buildSubscriberSB();
-    message.append(SEPARATOR);
-    message.append(subscriberName);
-    message.append(VALUE_SEPARATOR);
-    message.append(LABEL_SUBSCRIBER_ON_START);
-    message.append(LOG_ENCLOSING_CLOSE);
-
-    return message.toString();
-  }
-
-  String buildSubscriberOnNextMessage(String subscriberName, Object value, String threadName) {
-    final StringBuilder message = buildSubscriberSB();
-    message.append(SEPARATOR);
-    message.append(subscriberName);
-    message.append(VALUE_SEPARATOR);
-    message.append(LABEL_SUBSCRIBER_ON_NEXT);
-    message.append(VALUE_SEPARATOR);
-    message.append(value != null ? value.toString() : LABEL_MESSAGE_NULL_OBSERVABLES);
-    message.append(SEPARATOR);
-    message.append(LABEL_SUBSCRIBER_OBSERVE_ON);
-    message.append(threadName);
-    message.append(LOG_ENCLOSING_CLOSE);
-
-    return message.toString();
-  }
-
-  String buildSubscriberOnErrorMessage(String subscriberName, String error) {
-    final StringBuilder message = buildSubscriberSB();
-    message.append(SEPARATOR);
-    message.append(subscriberName);
-    message.append(VALUE_SEPARATOR);
-    message.append(LABEL_SUBSCRIBER_ON_ERROR);
-    message.append(VALUE_SEPARATOR);
-    message.append(error);
-    message.append(LOG_ENCLOSING_CLOSE);
-
-    return message.toString();
-  }
-
-  String buildSubscriberOnCompletedMessage(String subscriberName) {
-    final StringBuilder message = buildSubscriberSB();
-    message.append(SEPARATOR);
-    message.append(subscriberName);
-    message.append(VALUE_SEPARATOR);
-    message.append(LABEL_SUBSCRIBER_ON_COMPLETED);
-    message.append(LOG_ENCLOSING_CLOSE);
-
-    return message.toString();
-  }
-
-  String buildSubscriberItemTimeMessage(String subscriberName, long executionTimeMillis,
-      int receivedItems) {
-    final StringBuilder message = buildSubscriberSB();
-    message.append(SEPARATOR);
-    message.append(subscriberName);
-    message.append(VALUE_SEPARATOR);
-    message.append(RECEIVED_ELEMENTS_LABEL);
-    message.append(receivedItems);
-    message.append(receivedItems == 1 ? LABEL_ELEMENT_SINGULAR : LABEL_ELEMENT_PLURAL);
-    message.append(SEPARATOR);
-    message.append(TIME_LABEL);
-    message.append(executionTimeMillis);
-    message.append(TIME_MILLIS);
-    message.append(LOG_ENCLOSING_CLOSE);
-
-    return message.toString();
-  }
-
-  String buildSubscriberRequestedItemsMessage(String subscriberName, long requestedItems) {
-    final StringBuilder message = buildSubscriberSB();
-    message.append(SEPARATOR);
-    message.append(subscriberName);
-    message.append(VALUE_SEPARATOR);
-    message.append(REQUESTED_ELEMENTS_LABEL);
-    message.append(requestedItems);
-    message.append(requestedItems == 1 ? LABEL_ELEMENT_SINGULAR : LABEL_ELEMENT_PLURAL);
-    message.append(LOG_ENCLOSING_CLOSE);
-
-    return message.toString();
-  }
-
-  String buildSubscriberUnsubscribeMessage(String subscriberName) {
-    final StringBuilder message = buildSubscriberSB();
-    message.append(SEPARATOR);
-    message.append(subscriberName);
-    message.append(VALUE_SEPARATOR);
-    message.append(LABEL_SUBSCRIBER_UN_SUBSCRIBE);
-    message.append(LOG_ENCLOSING_CLOSE);
-
-    return message.toString();
-  }
-
   String buildObservableItemTimeInfoMessage(ObservableInfo observableInfo) {
     final int totalEmittedItems = observableInfo.getTotalEmittedItems().or(0);
     final long totalExecutionTime = observableInfo.getTotalExecutionTime().or(0L);
@@ -266,7 +147,7 @@ String buildObservableThreadInfoMessage(ObservableInfo observableInfo) {
     message.append(observableInfo.getMethodName());
     message.append(VALUE_SEPARATOR);
     if (subscribeOnThread.isPresent()) {
-      message.append(LABEL_OBSERVABLE_SUBSCRIBE_ON);
+      message.append(LABEL_SUBSCRIBER_SUBSCRIBE_ON);
       message.append(subscribeOnThread.get());
     }
     if (observeOnThread.isPresent()) {
@@ -279,15 +160,6 @@ String buildObservableThreadInfoMessage(ObservableInfo observableInfo) {
     return message.toString();
   }
 
-  private StringBuilder buildSubscriberSB() {
-    final int avgStringSize = 75;
-    final StringBuilder message = new StringBuilder(avgStringSize + LIBRARY_LABEL.length());
-    message.append(LIBRARY_LABEL);
-    message.append(LOG_ENCLOSING_OPEN);
-    message.append(SUBSCRIBER_LABEL);
-    return message;
-  }
-
   private StringBuilder buildObservableSB() {
     final int avgStringSize = 75;
     final StringBuilder message = new StringBuilder(avgStringSize + LIBRARY_LABEL.length());
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/MessageManager.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/ObservableMessageManager.java
similarity index 51%
rename from frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/MessageManager.java
rename to frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/ObservableMessageManager.java
index 43ff1d8..10eb1f6 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/MessageManager.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/ObservableMessageManager.java
@@ -1,17 +1,17 @@
-package com.fernandocejas.frodo.internal;
+package com.fernandocejas.frodo.internal.messenger;
 
 import com.fernandocejas.frodo.internal.observable.ObservableInfo;
 
-public class MessageManager {
+public class ObservableMessageManager {
 
-  private final MessageBuilder messageBuilder;
+  private final ObservableMessageBuilder messageBuilder;
   private final DebugLog debugLog;
 
-  public MessageManager() {
-    this(new MessageBuilder(), new DebugLog());
+  public ObservableMessageManager() {
+    this(new ObservableMessageBuilder(), new DebugLog());
   }
 
-  public MessageManager(MessageBuilder messageBuilder, DebugLog debugLog) {
+  public ObservableMessageManager(ObservableMessageBuilder messageBuilder, DebugLog debugLog) {
     this.messageBuilder = messageBuilder;
     this.debugLog = debugLog;
   }
@@ -32,7 +32,7 @@ public void printObservableOnSubscribe(ObservableInfo observableInfo) {
 
   public <T> void printObservableOnNextWithValue(ObservableInfo observableInfo, T value) {
     final String message =
-        messageBuilder.buildObservableOnNextWithValueMessage(observableInfo, value);
+            messageBuilder.buildObservableOnNextWithValueMessage(observableInfo, value);
     this.printMessage(observableInfo.getClassSimpleName(), message);
   }
 
@@ -42,9 +42,9 @@ public void printObservableOnNext(ObservableInfo observableInfo) {
   }
 
   public void printObservableOnError(ObservableInfo observableInfo,
-      Throwable throwable) {
+                                     Throwable throwable) {
     final String message =
-        messageBuilder.buildObservableOnErrorMessage(observableInfo, throwable.getMessage());
+            messageBuilder.buildObservableOnErrorMessage(observableInfo, throwable.getMessage());
     this.printMessage(observableInfo.getClassSimpleName(), message);
   }
 
@@ -63,49 +63,6 @@ public void printObservableOnUnsubscribe(ObservableInfo observableInfo) {
     this.printMessage(observableInfo.getClassSimpleName(), message);
   }
 
-  public void printSubscriberOnStart(String subscriberName) {
-    final String message = messageBuilder.buildSubscriberOnStartMessage(subscriberName);
-    this.printMessage(subscriberName, message);
-  }
-
-  public void printSubscriberOnNext(String subscriberName, Object value, String threadName) {
-    final String message =
-        messageBuilder.buildSubscriberOnNextMessage(subscriberName, value, threadName);
-    this.printMessage(subscriberName, message);
-  }
-
-  public void printSubscriberOnError(String subscriberName, String error, long executionTimeMillis,
-      int receivedItems) {
-    final String itemTimeMessage =
-        messageBuilder.buildSubscriberItemTimeMessage(subscriberName, executionTimeMillis,
-            receivedItems);
-    final String onErrorMessage =
-        messageBuilder.buildSubscriberOnErrorMessage(subscriberName, error);
-    this.printMessage(subscriberName, itemTimeMessage);
-    this.printMessage(subscriberName, onErrorMessage);
-  }
-
-  public void printSubscriberOnCompleted(String subscriberName, long executionTimeMillis,
-      int receivedItems) {
-    final String itemTimeMessage =
-        messageBuilder.buildSubscriberItemTimeMessage(subscriberName, executionTimeMillis,
-            receivedItems);
-    final String onCompleteMessage =
-        messageBuilder.buildSubscriberOnCompletedMessage(subscriberName);
-    this.printMessage(subscriberName, itemTimeMessage);
-    this.printMessage(subscriberName, onCompleteMessage);
-  }
-
-  public void printSubscriberRequestedItems(String subscriberName, long requestedItems) {
-    final String message =
-        messageBuilder.buildSubscriberRequestedItemsMessage(subscriberName, requestedItems);
-    this.printMessage(subscriberName, message);
-  }
-
-  public void printSubscriberUnsubscribe(String subscriberName) {
-    final String message = messageBuilder.buildSubscriberUnsubscribeMessage(subscriberName);
-    this.printMessage(subscriberName, message);
-  }
 
   public void printObservableItemTimeInfo(ObservableInfo observableInfo) {
     final String message = messageBuilder.buildObservableItemTimeInfoMessage(observableInfo);
@@ -114,9 +71,10 @@ public void printObservableItemTimeInfo(ObservableInfo observableInfo) {
 
   public void printObservableThreadInfo(ObservableInfo observableInfo) {
     if (observableInfo.getSubscribeOnThread().isPresent() ||
-        observableInfo.getObserveOnThread().isPresent()) {
+            observableInfo.getObserveOnThread().isPresent()) {
       final String message = messageBuilder.buildObservableThreadInfoMessage(observableInfo);
       this.printMessage(observableInfo.getClassSimpleName(), message);
     }
   }
+
 }
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SingleMessageBuilder.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SingleMessageBuilder.java
new file mode 100644
index 0000000..a31b587
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SingleMessageBuilder.java
@@ -0,0 +1,154 @@
+package com.fernandocejas.frodo.internal.messenger;
+
+import com.fernandocejas.frodo.core.optional.Optional;
+import com.fernandocejas.frodo.internal.single.SingleInfo;
+import com.fernandocejas.frodo.joinpoint.FrodoJoinPoint;
+
+import java.util.List;
+
+/**
+ * Class used to build different messages that will be shown in debug mode
+ */
+class SingleMessageBuilder extends MessengerBuilder {
+
+  private static final String SINGLE_LABEL = LOG_START + "Single";
+  private static final String LABEL_SINGLE_ON_SUBSCRIBE = "onSubscribe()";
+  private static final String LABEL_SINGLE_ON_SUCCESS = "onSuccess()";
+  private static final String LABEL_SINGLE_ON_ERROR = "onError()";
+  private static final String LABEL_SINGLE_ON_UNSUBSCRIBE = "onUnsubscribe()";
+
+
+  SingleMessageBuilder() {
+  }
+
+  String buildSingleInfoMessage(SingleInfo observableInfo) {
+    final FrodoJoinPoint joinPoint = observableInfo.getJoinPoint();
+    final StringBuilder message = buildSingleSB();
+    message.append(SEPARATOR);
+    message.append(CLASS_LABEL);
+    message.append(observableInfo.getClassSimpleName());
+    message.append(SEPARATOR);
+    message.append(METHOD_LABEL);
+    message.append(observableInfo.getMethodName());
+    message.append(buildMethodSignatureWithValues(joinPoint));
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  String buildSingleOnSubscribeMessage(SingleInfo observableInfo) {
+    final StringBuilder message = buildSingleSB();
+    message.append(METHOD_SEPARATOR);
+    message.append(observableInfo.getMethodName());
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SINGLE_ON_SUBSCRIBE);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  <T> String buildSingleOnSuccessWithValueMessage(SingleInfo observableInfo, T value) {
+    final StringBuilder message = buildSingleSB();
+    message.append(METHOD_SEPARATOR);
+    message.append(observableInfo.getMethodName());
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SINGLE_ON_SUCCESS);
+    message.append(VALUE_SEPARATOR);
+    message.append(String.valueOf(value));
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  String buildSingleOnSuccessMessage(SingleInfo observableInfo) {
+    final StringBuilder message = buildSingleSB();
+    message.append(METHOD_SEPARATOR);
+    message.append(observableInfo.getMethodName());
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SINGLE_ON_SUCCESS);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  String buildSingleOnErrorMessage(SingleInfo observableInfo, String errorMessage) {
+    final StringBuilder message = buildSingleSB();
+    message.append(METHOD_SEPARATOR);
+    message.append(observableInfo.getMethodName());
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SINGLE_ON_ERROR);
+    message.append(VALUE_SEPARATOR);
+    message.append(TEXT_ENCLOSING_SYMBOL);
+    message.append(errorMessage);
+    message.append(TEXT_ENCLOSING_SYMBOL);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+
+  String buildSingleOnUnsubscribeMessage(SingleInfo observableInfo) {
+    final StringBuilder message = buildSingleSB();
+    message.append(METHOD_SEPARATOR);
+    message.append(observableInfo.getMethodName());
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SINGLE_ON_UNSUBSCRIBE);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+
+  String buildSingleThreadInfoMessage(SingleInfo observableInfo) {
+    final Optional<String> subscribeOnThread = observableInfo.getSubscribeOnThread();
+    final Optional<String> observeOnThread = observableInfo.getObserveOnThread();
+    final StringBuilder message = buildSingleSB();
+    message.append(METHOD_SEPARATOR);
+    message.append(observableInfo.getMethodName());
+    message.append(VALUE_SEPARATOR);
+    if (subscribeOnThread.isPresent()) {
+      message.append(LABEL_SUBSCRIBER_SUBSCRIBE_ON);
+      message.append(subscribeOnThread.get());
+    }
+    if (observeOnThread.isPresent()) {
+      message.append(SEPARATOR);
+      message.append(LABEL_SUBSCRIBER_OBSERVE_ON);
+      message.append(observeOnThread.get());
+    }
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  private StringBuilder buildSingleSB() {
+    final int avgStringSize = 75;
+    final StringBuilder message = new StringBuilder(avgStringSize + LIBRARY_LABEL.length());
+    message.append(LIBRARY_LABEL);
+    message.append(LOG_ENCLOSING_OPEN);
+    message.append(SINGLE_LABEL);
+    return message;
+  }
+
+  private String buildMethodSignatureWithValues(FrodoJoinPoint joinPoint) {
+    final int avg = 30;
+    final StringBuilder stringBuilder = new StringBuilder(avg + joinPoint.getMethodName().length());
+    stringBuilder.append("(");
+    List<String> methodParamNames = joinPoint.getMethodParamNamesList();
+    if (methodParamNames != null && !methodParamNames.isEmpty()) {
+      for (int i = 0; i < joinPoint.getMethodParamNamesList().size(); i++) {
+        stringBuilder.append(methodParamNames.get(i));
+        stringBuilder.append("=");
+        stringBuilder.append("'");
+        stringBuilder.append(String.valueOf(joinPoint.getMethodParamValuesList().get(i)));
+        stringBuilder.append("'");
+        if ((i != methodParamNames.size() - 1)) {
+          stringBuilder.append(", ");
+        }
+      }
+    }
+    stringBuilder.append(")");
+
+    return stringBuilder.toString();
+  }
+
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SingleMessageManager.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SingleMessageManager.java
new file mode 100644
index 0000000..1f79f3b
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SingleMessageManager.java
@@ -0,0 +1,65 @@
+package com.fernandocejas.frodo.internal.messenger;
+
+import com.fernandocejas.frodo.internal.single.SingleInfo;
+
+public class SingleMessageManager {
+
+  private final SingleMessageBuilder messageBuilder;
+  private final DebugLog debugLog;
+
+  public SingleMessageManager() {
+    this(new SingleMessageBuilder(), new DebugLog());
+  }
+
+  public SingleMessageManager(SingleMessageBuilder messageBuilder, DebugLog debugLog) {
+    this.messageBuilder = messageBuilder;
+    this.debugLog = debugLog;
+  }
+
+  private void printMessage(String tag, String message) {
+    debugLog.log(tag, message);
+  }
+
+  public void printSingleInfo(SingleInfo singleInfo) {
+    final String message = messageBuilder.buildSingleInfoMessage(singleInfo);
+    this.printMessage(singleInfo.getClassSimpleName(), message);
+  }
+
+  public void printSingleOnSubscribe(SingleInfo singleInfo) {
+    final String message = messageBuilder.buildSingleOnSubscribeMessage(singleInfo);
+    this.printMessage(singleInfo.getClassSimpleName(), message);
+  }
+
+  public <T> void printSingleOnSuccessWithValue(SingleInfo singleInfo, T value) {
+    final String message =
+            messageBuilder.buildSingleOnSuccessWithValueMessage(singleInfo, value);
+    this.printMessage(singleInfo.getClassSimpleName(), message);
+  }
+
+  public void printSingleOnSuccess(SingleInfo singleInfo) {
+    final String message =
+            messageBuilder.buildSingleOnSuccessMessage(singleInfo);
+    this.printMessage(singleInfo.getClassSimpleName(), message);
+  }
+
+  public void printSingleOnError(SingleInfo singleInfo,
+                                 Throwable throwable) {
+    final String message =
+            messageBuilder.buildSingleOnErrorMessage(singleInfo, throwable.getMessage());
+    this.printMessage(singleInfo.getClassSimpleName(), message);
+  }
+
+  public void printSingleOnUnsubscribe(SingleInfo singleInfo) {
+    final String message = messageBuilder.buildSingleOnUnsubscribeMessage(singleInfo);
+    this.printMessage(singleInfo.getClassSimpleName(), message);
+  }
+
+  public void printSingleThreadInfo(SingleInfo singleInfo) {
+    if (singleInfo.getSubscribeOnThread().isPresent() ||
+            singleInfo.getObserveOnThread().isPresent()) {
+      final String message = messageBuilder.buildSingleThreadInfoMessage(singleInfo);
+      this.printMessage(singleInfo.getClassSimpleName(), message);
+    }
+  }
+
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SubscriberMessageBuilder.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SubscriberMessageBuilder.java
new file mode 100644
index 0000000..15ab0c3
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SubscriberMessageBuilder.java
@@ -0,0 +1,125 @@
+package com.fernandocejas.frodo.internal.messenger;
+
+/**
+ * Class used to build different messages that will be shown in debug mode
+ */
+class SubscriberMessageBuilder extends MessengerBuilder {
+
+  private static final String SUBSCRIBER_LABEL = LOG_START + "Subscriber";
+  private static final String LABEL_SUBSCRIBER_ON_START = "onStart()";
+  private static final String LABEL_SUBSCRIBER_ON_NEXT = "onNext()";
+  private static final String LABEL_SUBSCRIBER_ON_ERROR = "onError()";
+  private static final String LABEL_SUBSCRIBER_ON_COMPLETED = "onCompleted()";
+  private static final String LABEL_SUBSCRIBER_UN_SUBSCRIBE = "unSubscribe()";
+  private static final String REQUESTED_ELEMENTS_LABEL = LOG_START + "Requested" + VALUE_SEPARATOR;
+  private static final String RECEIVED_ELEMENTS_LABEL = LOG_START + "Received" + VALUE_SEPARATOR;
+  private static final String LABEL_MESSAGE_NULL_OBSERVABLES = "You received a null observable";
+
+  SubscriberMessageBuilder() {
+  }
+
+
+  String buildSubscriberOnStartMessage(String subscriberName) {
+    final StringBuilder message = buildSubscriberSB();
+    message.append(SEPARATOR);
+    message.append(subscriberName);
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SUBSCRIBER_ON_START);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  String buildSubscriberOnNextMessage(String subscriberName, Object value, String threadName) {
+    final StringBuilder message = buildSubscriberSB();
+    message.append(SEPARATOR);
+    message.append(subscriberName);
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SUBSCRIBER_ON_NEXT);
+    message.append(VALUE_SEPARATOR);
+    message.append(value != null ? value.toString() : LABEL_MESSAGE_NULL_OBSERVABLES);
+    message.append(SEPARATOR);
+    message.append(LABEL_SUBSCRIBER_OBSERVE_ON);
+    message.append(threadName);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  String buildSubscriberOnErrorMessage(String subscriberName, String error) {
+    final StringBuilder message = buildSubscriberSB();
+    message.append(SEPARATOR);
+    message.append(subscriberName);
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SUBSCRIBER_ON_ERROR);
+    message.append(VALUE_SEPARATOR);
+    message.append(error);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  String buildSubscriberOnCompletedMessage(String subscriberName) {
+    final StringBuilder message = buildSubscriberSB();
+    message.append(SEPARATOR);
+    message.append(subscriberName);
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SUBSCRIBER_ON_COMPLETED);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  String buildSubscriberItemTimeMessage(String subscriberName, long executionTimeMillis,
+                                        int receivedItems) {
+    final StringBuilder message = buildSubscriberSB();
+    message.append(SEPARATOR);
+    message.append(subscriberName);
+    message.append(VALUE_SEPARATOR);
+    message.append(RECEIVED_ELEMENTS_LABEL);
+    message.append(receivedItems);
+    message.append(receivedItems == 1 ? LABEL_ELEMENT_SINGULAR : LABEL_ELEMENT_PLURAL);
+    message.append(SEPARATOR);
+    message.append(TIME_LABEL);
+    message.append(executionTimeMillis);
+    message.append(TIME_MILLIS);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  String buildSubscriberRequestedItemsMessage(String subscriberName, long requestedItems) {
+    final StringBuilder message = buildSubscriberSB();
+    message.append(SEPARATOR);
+    message.append(subscriberName);
+    message.append(VALUE_SEPARATOR);
+    message.append(REQUESTED_ELEMENTS_LABEL);
+    message.append(requestedItems);
+    message.append(requestedItems == 1 ? LABEL_ELEMENT_SINGULAR : LABEL_ELEMENT_PLURAL);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+  String buildSubscriberUnsubscribeMessage(String subscriberName) {
+    final StringBuilder message = buildSubscriberSB();
+    message.append(SEPARATOR);
+    message.append(subscriberName);
+    message.append(VALUE_SEPARATOR);
+    message.append(LABEL_SUBSCRIBER_UN_SUBSCRIBE);
+    message.append(LOG_ENCLOSING_CLOSE);
+
+    return message.toString();
+  }
+
+
+  private StringBuilder buildSubscriberSB() {
+    final int avgStringSize = 75;
+    final StringBuilder message = new StringBuilder(avgStringSize + LIBRARY_LABEL.length());
+    message.append(LIBRARY_LABEL);
+    message.append(LOG_ENCLOSING_OPEN);
+    message.append(SUBSCRIBER_LABEL);
+    return message;
+  }
+
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SubscriberMessageManager.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SubscriberMessageManager.java
new file mode 100644
index 0000000..446fc77
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/messenger/SubscriberMessageManager.java
@@ -0,0 +1,67 @@
+package com.fernandocejas.frodo.internal.messenger;
+
+/**
+ *
+ */
+public class SubscriberMessageManager {
+
+  private final SubscriberMessageBuilder messageBuilder;
+  private final DebugLog debugLog;
+
+  public SubscriberMessageManager() {
+    this(new SubscriberMessageBuilder(), new DebugLog());
+  }
+
+  public SubscriberMessageManager(SubscriberMessageBuilder messageBuilder, DebugLog debugLog) {
+    this.messageBuilder = messageBuilder;
+    this.debugLog = debugLog;
+  }
+
+  private void printMessage(String tag, String message) {
+    debugLog.log(tag, message);
+  }
+
+  public void printSubscriberOnStart(String subscriberName) {
+    final String message = messageBuilder.buildSubscriberOnStartMessage(subscriberName);
+    this.printMessage(subscriberName, message);
+  }
+
+  public void printSubscriberOnNext(String subscriberName, Object value, String threadName) {
+    final String message =
+            messageBuilder.buildSubscriberOnNextMessage(subscriberName, value, threadName);
+    this.printMessage(subscriberName, message);
+  }
+
+  public void printSubscriberOnError(String subscriberName, String error, long executionTimeMillis,
+                                     int receivedItems) {
+    final String itemTimeMessage =
+            messageBuilder.buildSubscriberItemTimeMessage(subscriberName, executionTimeMillis,
+                    receivedItems);
+    final String onErrorMessage =
+            messageBuilder.buildSubscriberOnErrorMessage(subscriberName, error);
+    this.printMessage(subscriberName, itemTimeMessage);
+    this.printMessage(subscriberName, onErrorMessage);
+  }
+
+  public void printSubscriberOnCompleted(String subscriberName, long executionTimeMillis,
+                                         int receivedItems) {
+    final String itemTimeMessage =
+            messageBuilder.buildSubscriberItemTimeMessage(subscriberName, executionTimeMillis,
+                    receivedItems);
+    final String onCompleteMessage =
+            messageBuilder.buildSubscriberOnCompletedMessage(subscriberName);
+    this.printMessage(subscriberName, itemTimeMessage);
+    this.printMessage(subscriberName, onCompleteMessage);
+  }
+
+  public void printSubscriberRequestedItems(String subscriberName, long requestedItems) {
+    final String message =
+            messageBuilder.buildSubscriberRequestedItemsMessage(subscriberName, requestedItems);
+    this.printMessage(subscriberName, message);
+  }
+
+  public void printSubscriberUnsubscribe(String subscriberName) {
+    final String message = messageBuilder.buildSubscriberUnsubscribeMessage(subscriberName);
+    this.printMessage(subscriberName, message);
+  }
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/FrodoObservable.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/FrodoObservable.java
index 95fc358..2b3c04f 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/FrodoObservable.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/FrodoObservable.java
@@ -2,7 +2,7 @@
 
 import com.fernandocejas.frodo.annotation.RxLogObservable;
 import com.fernandocejas.frodo.core.strings.Strings;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 import java.lang.annotation.Annotation;
 
@@ -10,13 +10,13 @@
 public class FrodoObservable {
 
   private final FrodoProceedingJoinPoint joinPoint;
-  private final MessageManager messageManager;
+  private final ObservableMessageManager messageManager;
   private final ObservableInfo observableInfo;
   private final LoggableObservableFactory observableFactory;
 
   private String observeOnThread = Strings.EMPTY;
 
-  public FrodoObservable(FrodoProceedingJoinPoint joinPoint, MessageManager messageManager,
+  public FrodoObservable(FrodoProceedingJoinPoint joinPoint, ObservableMessageManager messageManager,
       LoggableObservableFactory observableFactory) {
     this.joinPoint = joinPoint;
     this.messageManager = messageManager;
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogEventsObservable.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogEventsObservable.java
index 7cabcb6..3d7d2c8 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogEventsObservable.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogEventsObservable.java
@@ -1,6 +1,6 @@
 package com.fernandocejas.frodo.internal.observable;
 
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 import rx.Observable;
 import rx.functions.Action0;
@@ -8,7 +8,7 @@
 
 @SuppressWarnings("unchecked") class LogEventsObservable extends LoggableObservable {
   LogEventsObservable(FrodoProceedingJoinPoint joinPoint,
-      MessageManager messageManager, ObservableInfo observableInfo) {
+                      ObservableMessageManager messageManager, ObservableInfo observableInfo) {
     super(joinPoint, messageManager, observableInfo);
   }
 
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogEverythingObservable.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogEverythingObservable.java
index 1ffec60..72f4cd4 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogEverythingObservable.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogEverythingObservable.java
@@ -1,7 +1,7 @@
 package com.fernandocejas.frodo.internal.observable;
 
 import com.fernandocejas.frodo.internal.Counter;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.internal.StopWatch;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 import rx.Notification;
@@ -11,7 +11,7 @@
 
 @SuppressWarnings("unchecked") class LogEverythingObservable extends LoggableObservable {
 
-  LogEverythingObservable(FrodoProceedingJoinPoint joinPoint, MessageManager messageManager,
+  LogEverythingObservable(FrodoProceedingJoinPoint joinPoint, ObservableMessageManager messageManager,
       ObservableInfo observableInfo) {
     super(joinPoint, messageManager, observableInfo);
   }
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogNothingObservable.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogNothingObservable.java
index 7533c9d..2b25731 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogNothingObservable.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogNothingObservable.java
@@ -1,13 +1,13 @@
 package com.fernandocejas.frodo.internal.observable;
 
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 import rx.Observable;
 
 @SuppressWarnings("unchecked") class LogNothingObservable extends LoggableObservable {
 
   LogNothingObservable(FrodoProceedingJoinPoint joinPoint,
-      MessageManager messageManager, ObservableInfo observableInfo) {
+                       ObservableMessageManager messageManager, ObservableInfo observableInfo) {
     super(joinPoint, messageManager, observableInfo);
   }
 
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogSchedulersObservable.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogSchedulersObservable.java
index 4362cfc..1c710d5 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogSchedulersObservable.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogSchedulersObservable.java
@@ -1,6 +1,6 @@
 package com.fernandocejas.frodo.internal.observable;
 
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 import rx.Notification;
 import rx.Observable;
@@ -9,7 +9,7 @@
 
 @SuppressWarnings("unchecked") class LogSchedulersObservable extends LoggableObservable {
   LogSchedulersObservable(FrodoProceedingJoinPoint joinPoint,
-      MessageManager messageManager, ObservableInfo observableInfo) {
+                          ObservableMessageManager messageManager, ObservableInfo observableInfo) {
     super(joinPoint, messageManager, observableInfo);
   }
 
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogStreamObservable.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogStreamObservable.java
index 0891158..2170117 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogStreamObservable.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LogStreamObservable.java
@@ -1,7 +1,7 @@
 package com.fernandocejas.frodo.internal.observable;
 
 import com.fernandocejas.frodo.internal.Counter;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.internal.StopWatch;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 import rx.Observable;
@@ -10,7 +10,7 @@
 
 @SuppressWarnings("unchecked") class LogStreamObservable extends LoggableObservable {
   LogStreamObservable(FrodoProceedingJoinPoint joinPoint,
-      MessageManager messageManager, ObservableInfo observableInfo) {
+                      ObservableMessageManager messageManager, ObservableInfo observableInfo) {
     super(joinPoint, messageManager, observableInfo);
   }
 
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LoggableObservable.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LoggableObservable.java
index da4f4ab..358623a 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LoggableObservable.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LoggableObservable.java
@@ -1,16 +1,16 @@
 package com.fernandocejas.frodo.internal.observable;
 
 import com.fernandocejas.frodo.core.annotations.VisibleForTesting;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 
 abstract class LoggableObservable {
 
   final FrodoProceedingJoinPoint joinPoint;
-  final MessageManager messageManager;
+  final ObservableMessageManager messageManager;
   final ObservableInfo observableInfo;
 
-  LoggableObservable(FrodoProceedingJoinPoint joinPoint, MessageManager messageManager,
+  LoggableObservable(FrodoProceedingJoinPoint joinPoint, ObservableMessageManager messageManager,
       ObservableInfo observableInfo) {
     this.joinPoint = joinPoint;
     this.messageManager = messageManager;
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LoggableObservableFactory.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LoggableObservableFactory.java
index 5e50294..1648a82 100644
--- a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LoggableObservableFactory.java
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/observable/LoggableObservableFactory.java
@@ -1,18 +1,18 @@
 package com.fernandocejas.frodo.internal.observable;
 
 import com.fernandocejas.frodo.annotation.RxLogObservable;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 import java.lang.annotation.Annotation;
 
 @SuppressWarnings("unchecked") public class LoggableObservableFactory {
 
   private final FrodoProceedingJoinPoint joinPoint;
-  private final MessageManager messageManager;
+  private final ObservableMessageManager messageManager;
   private final ObservableInfo observableInfo;
 
   public LoggableObservableFactory(FrodoProceedingJoinPoint joinPoint,
-      MessageManager messageManager, ObservableInfo observableInfo) {
+                                   ObservableMessageManager messageManager, ObservableInfo observableInfo) {
     this.joinPoint = joinPoint;
     this.messageManager = messageManager;
     this.observableInfo = observableInfo;
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/FrodoSingle.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/FrodoSingle.java
new file mode 100644
index 0000000..a4d7231
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/FrodoSingle.java
@@ -0,0 +1,31 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.annotation.RxLogSingle;
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+
+import java.lang.annotation.Annotation;
+
+public class FrodoSingle {
+
+  private final FrodoProceedingJoinPoint joinPoint;
+  private final SingleMessageManager messageManager;
+  private final SingleInfo singleInfo;
+  private final LoggableSingleFactory singleFactory;
+
+  public FrodoSingle(FrodoProceedingJoinPoint joinPoint, SingleMessageManager messageManager,
+                     LoggableSingleFactory singleFactory) {
+    this.joinPoint = joinPoint;
+    this.messageManager = messageManager;
+    this.singleInfo = new SingleInfo(joinPoint);
+    this.singleFactory = singleFactory;
+  }
+
+  public rx.Single getSingle() throws Throwable {
+    messageManager.printSingleInfo(singleInfo);
+    final Class singleType = joinPoint.getGenericReturnTypes().get(0);
+    final Annotation annotation = joinPoint.getAnnotation(RxLogSingle.class);
+    return singleFactory.create(annotation).get(singleType);
+  }
+
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogEventsSingle.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogEventsSingle.java
new file mode 100644
index 0000000..c84ecbf
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogEventsSingle.java
@@ -0,0 +1,45 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+
+import rx.Single;
+import rx.functions.Action0;
+import rx.functions.Action1;
+
+@SuppressWarnings("unchecked")
+class LogEventsSingle extends LoggableSingle {
+  LogEventsSingle(FrodoProceedingJoinPoint joinPoint,
+                  SingleMessageManager messageManager, SingleInfo singleInfo) {
+    super(joinPoint, messageManager, singleInfo);
+  }
+
+  @Override
+  <T> Single<T> get(T type) throws Throwable {
+    return ((Single<T>) joinPoint.proceed())
+            .doOnSubscribe(new Action0() {
+              @Override
+              public void call() {
+                messageManager.printSingleOnSubscribe(singleInfo);
+              }
+            })
+            .doOnSuccess(new Action1<T>() {
+              @Override
+              public void call(T value) {
+                messageManager.printSingleOnSuccess(singleInfo);
+              }
+            })
+            .doOnError(new Action1<Throwable>() {
+              @Override
+              public void call(Throwable throwable) {
+                messageManager.printSingleOnError(singleInfo, throwable);
+              }
+            })
+            .doOnUnsubscribe(new Action0() {
+              @Override
+              public void call() {
+                messageManager.printSingleOnUnsubscribe(singleInfo);
+              }
+            });
+  }
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogEverythingSingle.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogEverythingSingle.java
new file mode 100644
index 0000000..26c9816
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogEverythingSingle.java
@@ -0,0 +1,67 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.internal.StopWatch;
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+
+import rx.Notification;
+import rx.Single;
+import rx.functions.Action0;
+import rx.functions.Action1;
+
+@SuppressWarnings("unchecked")
+class LogEverythingSingle extends LoggableSingle {
+
+  LogEverythingSingle(FrodoProceedingJoinPoint joinPoint, SingleMessageManager messageManager,
+                      SingleInfo singleInfo) {
+    super(joinPoint, messageManager, singleInfo);
+  }
+
+  @Override
+  <T> rx.Single<T> get(T type) throws Throwable {
+    final StopWatch stopWatch = new StopWatch();
+    return ((Single<T>) joinPoint.proceed())
+            .doOnSubscribe(new Action0() {
+              @Override
+              public void call() {
+                stopWatch.start();
+                messageManager.printSingleOnSubscribe(singleInfo);
+              }
+            })
+            .doOnEach(new Action1<Notification<? extends T>>() {
+              @Override
+              public void call(Notification<? extends T> notification) {
+                if (!singleInfo.getSubscribeOnThread().isPresent()
+                        && (notification.isOnNext() || notification.isOnError())) {
+                  singleInfo.setSubscribeOnThread(Thread.currentThread().getName());
+                }
+              }
+            })
+            .doOnSuccess(new Action1<T>() {
+              @Override
+              public void call(T value) {
+                stopWatch.stop();
+                singleInfo.setTotalExecutionTime(stopWatch.getTotalTimeMillis());
+                messageManager.printSingleOnSuccessWithValue(singleInfo, value);
+              }
+            })
+            .doOnError(new Action1<Throwable>() {
+              @Override
+              public void call(Throwable throwable) {
+                stopWatch.stop();
+                singleInfo.setTotalExecutionTime(stopWatch.getTotalTimeMillis());
+                messageManager.printSingleOnError(singleInfo, throwable);
+              }
+            })
+            .doOnUnsubscribe(new Action0() {
+              @Override
+              public void call() {
+                if (!singleInfo.getObserveOnThread().isPresent()) {
+                  singleInfo.setObserveOnThread(Thread.currentThread().getName());
+                }
+                messageManager.printSingleThreadInfo(singleInfo);
+                messageManager.printSingleOnUnsubscribe(singleInfo);
+              }
+            });
+  }
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogNothingSingle.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogNothingSingle.java
new file mode 100644
index 0000000..1083754
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogNothingSingle.java
@@ -0,0 +1,18 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+
+import rx.Single;
+
+@SuppressWarnings("unchecked") class LogNothingSingle extends LoggableSingle {
+
+  LogNothingSingle(FrodoProceedingJoinPoint joinPoint,
+                   SingleMessageManager messageManager, SingleInfo singleInfo) {
+    super(joinPoint, messageManager, singleInfo);
+  }
+
+  @Override <T> Single<T> get(T type) throws Throwable {
+    return ((Single<T>) joinPoint.proceed());
+  }
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogSchedulersSingle.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogSchedulersSingle.java
new file mode 100644
index 0000000..38d8520
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LogSchedulersSingle.java
@@ -0,0 +1,40 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+
+import rx.Notification;
+import rx.Single;
+import rx.functions.Action0;
+import rx.functions.Action1;
+
+@SuppressWarnings("unchecked")
+class LogSchedulersSingle extends LoggableSingle {
+	LogSchedulersSingle(FrodoProceedingJoinPoint joinPoint,
+						SingleMessageManager messageManager, SingleInfo singleInfo) {
+		super(joinPoint, messageManager, singleInfo);
+	}
+
+	@Override
+	<T> Single<T> get(T type) throws Throwable {
+		return ((Single<T>) joinPoint.proceed())
+				.doOnEach(new Action1<Notification<? extends T>>() {
+					@Override
+					public void call(Notification<? extends T> notification) {
+						if (!singleInfo.getSubscribeOnThread().isPresent()
+								&& (notification.isOnNext() || notification.isOnError())) {
+							singleInfo.setSubscribeOnThread(Thread.currentThread().getName());
+						}
+					}
+				})
+				.doOnUnsubscribe(new Action0() {
+					@Override
+					public void call() {
+						if (!singleInfo.getObserveOnThread().isPresent()) {
+							singleInfo.setObserveOnThread(Thread.currentThread().getName());
+						}
+						messageManager.printSingleThreadInfo(singleInfo);
+					}
+				});
+	}
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LoggableSingle.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LoggableSingle.java
new file mode 100644
index 0000000..999ee18
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LoggableSingle.java
@@ -0,0 +1,26 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.core.annotations.VisibleForTesting;
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+
+abstract class LoggableSingle {
+
+	final FrodoProceedingJoinPoint joinPoint;
+	final SingleMessageManager messageManager;
+	final SingleInfo singleInfo;
+
+	LoggableSingle(FrodoProceedingJoinPoint joinPoint, SingleMessageManager messageManager,
+				   SingleInfo singleInfo) {
+		this.joinPoint = joinPoint;
+		this.messageManager = messageManager;
+		this.singleInfo = new SingleInfo(joinPoint);
+	}
+
+	abstract <T> rx.Single<T> get(T type) throws Throwable;
+
+	@VisibleForTesting
+	SingleInfo getInfo() {
+		return singleInfo;
+	}
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LoggableSingleFactory.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LoggableSingleFactory.java
new file mode 100644
index 0000000..3b01d49
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/LoggableSingleFactory.java
@@ -0,0 +1,40 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.annotation.RxLogSingle;
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+
+import java.lang.annotation.Annotation;
+
+@SuppressWarnings("unchecked") public class LoggableSingleFactory {
+
+  private final FrodoProceedingJoinPoint joinPoint;
+  private final SingleMessageManager messageManager;
+  private final SingleInfo singleInfo;
+
+  public LoggableSingleFactory(FrodoProceedingJoinPoint joinPoint,
+                               SingleMessageManager messageManager, SingleInfo singleInfo) {
+    this.joinPoint = joinPoint;
+    this.messageManager = messageManager;
+    this.singleInfo = singleInfo;
+  }
+
+  LoggableSingle create(Annotation annotation) {
+    final Class observableType = joinPoint.getGenericReturnTypes().get(0);
+    if (annotation != null) {
+      switch (((RxLogSingle) annotation).value()) {
+        case NOTHING:
+          return new LogNothingSingle(joinPoint, messageManager, singleInfo);
+        case SCHEDULERS:
+          return new LogSchedulersSingle(joinPoint, messageManager, singleInfo);
+        case EVENTS:
+          return new LogEventsSingle(joinPoint, messageManager, singleInfo);
+        case EVERYTHING:
+        default:
+          return new LogEverythingSingle(joinPoint, messageManager, singleInfo);
+      }
+    } else {
+      return new LogNothingSingle(joinPoint, messageManager, singleInfo);
+    }
+  }
+}
diff --git a/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/SingleInfo.java b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/SingleInfo.java
new file mode 100644
index 0000000..29e78ee
--- /dev/null
+++ b/frodo-runtime/src/main/java/com/fernandocejas/frodo/internal/single/SingleInfo.java
@@ -0,0 +1,56 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.core.optional.Optional;
+import com.fernandocejas.frodo.joinpoint.FrodoJoinPoint;
+
+public class SingleInfo {
+  private final FrodoJoinPoint joinPoint;
+
+  private String subscribeOnThread;
+  private String observeOnThread;
+  private long totalExecutionTime;
+
+  public SingleInfo(FrodoJoinPoint joinPoint) {
+    this.joinPoint = joinPoint;
+  }
+
+  public String getClassSimpleName() {
+    return joinPoint.getClassSimpleName();
+  }
+
+  public String getMethodName() {
+    return joinPoint.getMethodName();
+  }
+
+  public FrodoJoinPoint getJoinPoint() {
+    return joinPoint;
+  }
+
+  public Optional<String> getSubscribeOnThread() {
+    return Optional.fromNullable(subscribeOnThread);
+  }
+
+  public Optional<String> getObserveOnThread() {
+    return Optional.fromNullable(observeOnThread);
+  }
+
+  public Optional<Long> getTotalExecutionTime() {
+    if (totalExecutionTime == 0) {
+      return Optional.absent();
+    }
+    return Optional.of(totalExecutionTime);
+  }
+
+  void setSubscribeOnThread(String subscribeOnThread) {
+    this.subscribeOnThread = subscribeOnThread;
+  }
+
+  void setObserveOnThread(String observeOnThread) {
+    this.observeOnThread = observeOnThread;
+  }
+
+  void setTotalExecutionTime(long totalExecutionTime) {
+    this.totalExecutionTime = totalExecutionTime;
+  }
+
+}
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/aspect/LogSingleTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/aspect/LogSingleTest.java
new file mode 100644
index 0000000..81f05b2
--- /dev/null
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/aspect/LogSingleTest.java
@@ -0,0 +1,23 @@
+package com.fernandocejas.frodo.aspect;
+
+import com.fernandocejas.frodo.joinpoint.TestJoinPoint;
+import com.fernandocejas.frodo.joinpoint.TestProceedingJoinPoint;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LogSingleTest {
+
+  @Test
+  public void shouldNotWeaveAroundMethodReturningOtherTypeThanSingle() {
+    final TestJoinPoint joinPoint = new TestJoinPoint.Builder(this.getClass(), "toString")
+        .withReturnType(this.getClass()).build();
+    final TestProceedingJoinPoint proceedingJoinPoint = new TestProceedingJoinPoint(joinPoint);
+
+    assertThat(LogSingle.methodAnnotatedWithRxLogSingle(proceedingJoinPoint)).isFalse();
+  }
+}
\ No newline at end of file
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/aspect/LogSubscriberTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/aspect/LogSubscriberTest.java
index c766bd3..644d90b 100644
--- a/frodo-runtime/src/test/java/com/fernandocejas/frodo/aspect/LogSubscriberTest.java
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/aspect/LogSubscriberTest.java
@@ -1,16 +1,18 @@
 package com.fernandocejas.frodo.aspect;
 
 import com.fernandocejas.frodo.internal.Counter;
-import com.fernandocejas.frodo.internal.MessageManager;
 import com.fernandocejas.frodo.internal.StopWatch;
+import com.fernandocejas.frodo.internal.messenger.SubscriberMessageManager;
 import com.fernandocejas.frodo.joinpoint.TestJoinPoint;
 import com.fernandocejas.frodo.joinpoint.TestProceedingJoinPoint;
+
 import org.aspectj.lang.JoinPoint;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
+
 import rx.observers.TestSubscriber;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -31,7 +33,7 @@ public class LogSubscriberTest {
 
   @Mock private Counter counter;
   @Mock private StopWatch stopWatch;
-  @Mock private MessageManager messageManager;
+  @Mock private SubscriberMessageManager messageManager;
 
   private TestSubscriber subscriber;
   private TestJoinPoint joinPoint;
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/FrodoObservableTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/FrodoObservableTest.java
index df0e399..30995e7 100644
--- a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/FrodoObservableTest.java
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/FrodoObservableTest.java
@@ -1,14 +1,17 @@
 package com.fernandocejas.frodo.internal.observable;
 
-import com.fernandocejas.frodo.internal.MessageManager;
-import java.lang.annotation.Annotation;
-import java.util.Collections;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
+
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
+
+import java.lang.annotation.Annotation;
+import java.util.Collections;
+
 import rx.observers.TestSubscriber;
 
 import static org.mockito.BDDMockito.given;
@@ -24,7 +27,7 @@ public class FrodoObservableTest {
   private FrodoObservable frodoObservable;
   private TestSubscriber subscriber;
 
-  @Mock private MessageManager messageManager;
+  @Mock private ObservableMessageManager messageManager;
   @Mock private LoggableObservableFactory observableFactory;
 
   @Before
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogEventsObservableTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogEventsObservableTest.java
index 029f379..054f53c 100644
--- a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogEventsObservableTest.java
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogEventsObservableTest.java
@@ -1,6 +1,6 @@
 package com.fernandocejas.frodo.internal.observable;
 
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -21,7 +21,7 @@ public class LogEventsObservableTest {
   private LogEventsObservable loggableObservable;
   private TestSubscriber subscriber;
 
-  @Mock private MessageManager messageManager;
+  @Mock private ObservableMessageManager messageManager;
 
   @Before
   public void setUp() {
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogEverythingObservableTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogEverythingObservableTest.java
index 28b9015..419f0a9 100644
--- a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogEverythingObservableTest.java
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogEverythingObservableTest.java
@@ -1,15 +1,18 @@
 package com.fernandocejas.frodo.internal.observable;
 
 import com.fernandocejas.frodo.core.optional.Optional;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
-import java.util.concurrent.TimeUnit;
+
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
+
+import java.util.concurrent.TimeUnit;
+
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 
@@ -26,7 +29,7 @@ public class LogEverythingObservableTest {
   private LogEverythingObservable loggableObservable;
   private TestSubscriber subscriber;
 
-  @Mock private MessageManager messageManager;
+  @Mock private ObservableMessageManager messageManager;
 
   @Before
   public void setUp() {
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogNothingObservableTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogNothingObservableTest.java
index 0c96347..a46436d 100644
--- a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogNothingObservableTest.java
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogNothingObservableTest.java
@@ -1,6 +1,6 @@
 package com.fernandocejas.frodo.internal.observable;
 
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -19,7 +19,7 @@ public class LogNothingObservableTest {
   private LogNothingObservable loggableObservable;
   private TestSubscriber subscriber;
 
-  @Mock private MessageManager messageManager;
+  @Mock private ObservableMessageManager messageManager;
 
   @Before
   public void setUp() {
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogSchedulersObservableTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogSchedulersObservableTest.java
index 85ededf..6aa6147 100644
--- a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogSchedulersObservableTest.java
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogSchedulersObservableTest.java
@@ -1,7 +1,7 @@
 package com.fernandocejas.frodo.internal.observable;
 
 import com.fernandocejas.frodo.core.optional.Optional;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -24,7 +24,7 @@ public class LogSchedulersObservableTest {
   private LogSchedulersObservable loggableObservable;
   private TestSubscriber subscriber;
 
-  @Mock private MessageManager messageManager;
+  @Mock private ObservableMessageManager messageManager;
 
   @Before
   public void setUp() {
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogStreamObservableTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogStreamObservableTest.java
index 69e6a41..cd78faa 100644
--- a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogStreamObservableTest.java
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/LogStreamObservableTest.java
@@ -1,7 +1,7 @@
 package com.fernandocejas.frodo.internal.observable;
 
 import com.fernandocejas.frodo.core.optional.Optional;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import java.util.concurrent.TimeUnit;
 import org.junit.Before;
 import org.junit.Rule;
@@ -26,7 +26,7 @@ public class LogStreamObservableTest {
   private LogStreamObservable loggableObservable;
   private TestSubscriber subscriber;
 
-  @Mock private MessageManager messageManager;
+  @Mock private ObservableMessageManager messageManager;
 
   @Before
   public void setUp() {
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/ObservableRule.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/ObservableRule.java
index 91ec275..befae46 100644
--- a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/ObservableRule.java
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/observable/ObservableRule.java
@@ -1,7 +1,7 @@
 package com.fernandocejas.frodo.internal.observable;
 
 import com.fernandocejas.frodo.core.strings.Strings;
-import com.fernandocejas.frodo.internal.MessageManager;
+import com.fernandocejas.frodo.internal.messenger.ObservableMessageManager;
 import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
 import com.fernandocejas.frodo.joinpoint.TestJoinPoint;
 import com.fernandocejas.frodo.joinpoint.TestProceedingJoinPoint;
@@ -21,7 +21,7 @@ class ObservableRule implements TestRule {
   private FrodoProceedingJoinPoint frodoProceedingJoinPoint;
   private ObservableInfo observableInfo;
 
-  @Mock private MessageManager messageManager;
+  @Mock private ObservableMessageManager messageManager;
 
   ObservableRule(Class declaringType) {
     MockitoAnnotations.initMocks(this);
@@ -45,7 +45,7 @@ FrodoProceedingJoinPoint joinPoint() {
     return frodoProceedingJoinPoint;
   }
 
-  MessageManager messageManager() {
+  ObservableMessageManager messageManager() {
     return messageManager;
   }
 
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/FrodoSingleTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/FrodoSingleTest.java
new file mode 100644
index 0000000..bcdda91
--- /dev/null
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/FrodoSingleTest.java
@@ -0,0 +1,72 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.lang.annotation.Annotation;
+import java.util.Collections;
+
+import rx.observers.TestSubscriber;
+
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+
+@SuppressWarnings("unchecked")
+@RunWith(MockitoJUnitRunner.class)
+public class FrodoSingleTest {
+
+  @Rule public SingleRule singleRule = new SingleRule(this.getClass());
+
+  private FrodoSingle frodoSingle;
+  private TestSubscriber subscriber;
+
+  @Mock private SingleMessageManager messageManager;
+  @Mock private LoggableSingleFactory observableFactory;
+
+  @Before
+  public void setUp() {
+    frodoSingle =
+        new FrodoSingle(singleRule.joinPoint(), messageManager, observableFactory);
+    subscriber = new TestSubscriber();
+
+    given(observableFactory.create(any(Annotation.class))).willReturn(
+        createLogEverythingSingle());
+  }
+
+  @Test
+  public void shouldPrintSingleInfo() throws Throwable {
+    frodoSingle.getSingle();
+
+    verify(messageManager).printSingleInfo(any(SingleInfo.class));
+  }
+
+  @Test
+  public void shouldBuildSingle() throws Throwable {
+    frodoSingle.getSingle().subscribe(subscriber);
+
+    subscriber.assertReceivedOnNext(
+        Collections.singletonList(singleRule.OBSERVABLE_STREAM_VALUE));
+    subscriber.assertNoErrors();
+    subscriber.assertCompleted();
+    subscriber.assertUnsubscribed();
+  }
+
+  @Test
+  public void shouldLogSingleInformation() throws Throwable {
+    frodoSingle.getSingle().subscribe(subscriber);
+
+    verify(messageManager).printSingleInfo(any(SingleInfo.class));
+  }
+
+  private LogEverythingSingle createLogEverythingSingle() {
+    return new LogEverythingSingle(singleRule.joinPoint(), messageManager,
+        new SingleInfo(singleRule.joinPoint()));
+  }
+}
\ No newline at end of file
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogEventsSingleTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogEventsSingleTest.java
new file mode 100644
index 0000000..0b42c13
--- /dev/null
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogEventsSingleTest.java
@@ -0,0 +1,44 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import rx.observers.TestSubscriber;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+@SuppressWarnings("unchecked") @RunWith(MockitoJUnitRunner.class)
+public class LogEventsSingleTest {
+
+  @Rule public SingleRule singleRule = new SingleRule(this.getClass());
+
+  private LogEventsSingle loggableSingle;
+  private TestSubscriber subscriber;
+
+  @Mock private SingleMessageManager messageManager;
+
+  @Before
+  public void setUp() {
+    subscriber = new TestSubscriber();
+    loggableSingle =
+        new LogEventsSingle(singleRule.joinPoint(), messageManager, singleRule.info());
+  }
+
+  @Test
+  public void shouldLogOnlySingleEvents() throws Throwable {
+    loggableSingle.get(singleRule.stringType()).subscribe(subscriber);
+
+    verify(messageManager).printSingleOnSubscribe(any(SingleInfo.class));
+    verify(messageManager).printSingleOnSuccess(any(SingleInfo.class));
+    verify(messageManager).printSingleOnUnsubscribe(any(SingleInfo.class));
+    verifyNoMoreInteractions(messageManager);
+  }
+}
\ No newline at end of file
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogEverythingSingleTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogEverythingSingleTest.java
new file mode 100644
index 0000000..5beb353
--- /dev/null
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogEverythingSingleTest.java
@@ -0,0 +1,95 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.core.optional.Optional;
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.util.concurrent.TimeUnit;
+
+import rx.observers.TestSubscriber;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.verify;
+import static rx.schedulers.Schedulers.immediate;
+
+@SuppressWarnings("unchecked")
+@RunWith(MockitoJUnitRunner.class)
+public class LogEverythingSingleTest {
+
+  @Rule
+  public SingleRule singleRule = new SingleRule(this.getClass());
+
+  private LogEverythingSingle loggableSingle;
+  private TestSubscriber subscriber;
+
+  @Mock
+  private SingleMessageManager messageManager;
+
+  @Before
+  public void setUp() {
+    subscriber = new TestSubscriber();
+    loggableSingle = new LogEverythingSingle(singleRule.joinPoint(), messageManager,
+            singleRule.info());
+  }
+
+  @Test
+  public void shouldLogEverythingSingle() throws Throwable {
+    loggableSingle.get(singleRule.stringType()).subscribe(subscriber);
+
+    verify(messageManager).printSingleOnSubscribe(any(SingleInfo.class));
+    verify(messageManager).printSingleOnSuccessWithValue(any(SingleInfo.class), anyString());
+    verify(messageManager).printSingleOnUnsubscribe(any(SingleInfo.class));
+    verify(messageManager).printSingleThreadInfo(any(SingleInfo.class));
+  }
+
+  @Test
+  public void shouldFillInSingleBasicInfo() throws Throwable {
+    loggableSingle.get(singleRule.stringType()).subscribe(subscriber);
+    final SingleInfo observableInfo = loggableSingle.getInfo();
+    final FrodoProceedingJoinPoint frodoProceedingJoinPoint = singleRule.joinPoint();
+
+    assertThat(observableInfo.getClassSimpleName()).isEqualTo(
+            frodoProceedingJoinPoint.getClassSimpleName());
+    assertThat(observableInfo.getJoinPoint()).isEqualTo(frodoProceedingJoinPoint);
+    assertThat(observableInfo.getMethodName()).isEqualTo(frodoProceedingJoinPoint.getMethodName());
+  }
+
+  @Test
+  public void shouldFillInSingleThreadInfo() throws Throwable {
+    loggableSingle.get(singleRule.stringType())
+            .subscribeOn(immediate())
+            .observeOn(immediate())
+            .subscribe(subscriber);
+
+    final SingleInfo observableInfo = loggableSingle.getInfo();
+    final Optional<String> subscribeOnThread = observableInfo.getSubscribeOnThread();
+    final Optional<String> observeOnThread = observableInfo.getObserveOnThread();
+    final String currentThreadName = Thread.currentThread().getName();
+
+    assertThat(subscribeOnThread.isPresent()).isTrue();
+    assertThat(observeOnThread.isPresent()).isTrue();
+    assertThat(subscribeOnThread.get()).isEqualTo(currentThreadName);
+    assertThat(observeOnThread.get()).isEqualTo(currentThreadName);
+  }
+
+  @Test
+  public void shouldFillInSingleItemsInfo() throws Throwable {
+    loggableSingle.get(singleRule.stringType())
+            .delay(3, TimeUnit.SECONDS)
+            .subscribe(subscriber);
+
+    final SingleInfo observableInfo = loggableSingle.getInfo();
+    final Optional<Long> totalExecutionTime = observableInfo.getTotalExecutionTime();
+
+    assertThat(totalExecutionTime.isPresent()).isTrue();
+  }
+}
\ No newline at end of file
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogNothingSingleTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogNothingSingleTest.java
new file mode 100644
index 0000000..c13fc16
--- /dev/null
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogNothingSingleTest.java
@@ -0,0 +1,44 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import rx.observers.TestSubscriber;
+
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+@SuppressWarnings("unchecked")
+@RunWith(MockitoJUnitRunner.class)
+public class LogNothingSingleTest {
+
+  @Rule
+  public SingleRule singleRule = new SingleRule(this.getClass());
+
+  private LogNothingSingle loggableSingle;
+  private TestSubscriber subscriber;
+
+  @Mock
+  private SingleMessageManager messageManager;
+
+  @Before
+  public void setUp() {
+    subscriber = new TestSubscriber();
+    loggableSingle = new LogNothingSingle(singleRule.joinPoint(), messageManager,
+            singleRule.info());
+  }
+
+  @Test
+  public void shouldNotLogAnything() throws Throwable {
+    loggableSingle.get(singleRule.stringType()).subscribe(subscriber);
+
+    subscriber.assertNoErrors();
+    subscriber.assertCompleted();
+    verifyZeroInteractions(messageManager);
+  }
+}
\ No newline at end of file
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogSchedulersSingleTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogSchedulersSingleTest.java
new file mode 100644
index 0000000..92dfbd9
--- /dev/null
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LogSchedulersSingleTest.java
@@ -0,0 +1,67 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.core.optional.Optional;
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+@SuppressWarnings("unchecked")
+@RunWith(MockitoJUnitRunner.class)
+public class LogSchedulersSingleTest {
+
+  @Rule
+  public SingleRule singleRule = new SingleRule(this.getClass());
+
+  private LogSchedulersSingle loggableSingle;
+  private TestSubscriber subscriber;
+
+  @Mock
+  private SingleMessageManager messageManager;
+
+  @Before
+  public void setUp() {
+    subscriber = new TestSubscriber();
+    loggableSingle =
+            new LogSchedulersSingle(singleRule.joinPoint(), messageManager,
+                    singleRule.info());
+  }
+
+  @Test
+  public void shouldLogOnlySingleSchedulers() throws Throwable {
+    loggableSingle.get(singleRule.stringType()).subscribe(subscriber);
+
+    verify(messageManager).printSingleThreadInfo(any(SingleInfo.class));
+    verifyNoMoreInteractions(messageManager);
+  }
+
+  @Test
+  public void shouldFillInSingleThreadInfo() throws Throwable {
+    loggableSingle.get(singleRule.stringType())
+            .subscribeOn(Schedulers.immediate())
+            .observeOn(Schedulers.immediate())
+            .subscribe(subscriber);
+
+    final SingleInfo observableInfo = loggableSingle.getInfo();
+    final Optional<String> subscribeOnThread = observableInfo.getSubscribeOnThread();
+    final Optional<String> observeOnThread = observableInfo.getObserveOnThread();
+    final String currentThreadName = Thread.currentThread().getName();
+
+    assertThat(subscribeOnThread.isPresent()).isTrue();
+    assertThat(observeOnThread.isPresent()).isTrue();
+    assertThat(subscribeOnThread.get()).isEqualTo(currentThreadName);
+    assertThat(observeOnThread.get()).isEqualTo(currentThreadName);
+  }
+}
\ No newline at end of file
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LoggableSingleFactoryTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LoggableSingleFactoryTest.java
new file mode 100644
index 0000000..a5993e4
--- /dev/null
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/LoggableSingleFactoryTest.java
@@ -0,0 +1,68 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.annotation.RxLogSingle;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LoggableSingleFactoryTest {
+
+  @Rule
+  public final SingleRule singleRule = new SingleRule(this.getClass());
+
+  private LoggableSingleFactory observableFactory;
+
+  @Before
+  public void setUp() {
+    observableFactory = new LoggableSingleFactory(singleRule.joinPoint(),
+            singleRule.messageManager(), singleRule.info());
+  }
+
+  @Test
+  public void shouldCreateLogEverythingSingle() {
+    final RxLogSingle annotation = mock(RxLogSingle.class);
+    given(annotation.value()).willReturn(RxLogSingle.Scope.EVERYTHING);
+
+    final LoggableSingle loggableSingle = observableFactory.create(annotation);
+
+    assertThat(loggableSingle).isInstanceOf(LogEverythingSingle.class);
+  }
+
+  @Test
+  public void shouldCreateLogEventsSingle() {
+    final RxLogSingle annotation = mock(RxLogSingle.class);
+    given(annotation.value()).willReturn(RxLogSingle.Scope.EVENTS);
+
+    final LoggableSingle loggableSingle = observableFactory.create(annotation);
+
+    assertThat(loggableSingle).isInstanceOf(LogEventsSingle.class);
+  }
+
+  @Test
+  public void shouldCreateLogSchedulersSingle() {
+    final RxLogSingle annotation = mock(RxLogSingle.class);
+    given(annotation.value()).willReturn(RxLogSingle.Scope.SCHEDULERS);
+
+    final LoggableSingle loggableSingle = observableFactory.create(annotation);
+
+    assertThat(loggableSingle).isInstanceOf(LogSchedulersSingle.class);
+  }
+
+  @Test
+  public void shouldCreateLogNothingSingle() {
+    final RxLogSingle annotation = mock(RxLogSingle.class);
+    given(annotation.value()).willReturn(RxLogSingle.Scope.NOTHING);
+
+    final LoggableSingle loggableSingle = observableFactory.create(annotation);
+
+    assertThat(loggableSingle).isInstanceOf(LogNothingSingle.class);
+  }
+}
\ No newline at end of file
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/SingleInfoTest.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/SingleInfoTest.java
new file mode 100644
index 0000000..0e05982
--- /dev/null
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/SingleInfoTest.java
@@ -0,0 +1,58 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.core.optional.Optional;
+import com.fernandocejas.frodo.joinpoint.FrodoJoinPoint;
+import com.fernandocejas.frodo.joinpoint.TestJoinPoint;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import rx.Single;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SingleInfoTest {
+
+  private static final String OBSERVABLE_STREAM_VALUE = "fernando";
+
+  private SingleInfo singleInfo;
+
+  @Before
+  public void setUp() {
+    final TestJoinPoint testJoinPoint = new TestJoinPoint.Builder(this.getClass())
+            .withReturnType(Single.class)
+            .withReturnValue(OBSERVABLE_STREAM_VALUE)
+            .build();
+    final FrodoJoinPoint frodoJoinPoint = new FrodoJoinPoint(testJoinPoint);
+    singleInfo = new SingleInfo(frodoJoinPoint);
+  }
+
+  @Test
+  public void shouldReturnAbsentValues() {
+    final Optional<String> optionalSubscribeOnThread = singleInfo.getSubscribeOnThread();
+    final Optional<String> optionalObserveOnThread = singleInfo.getObserveOnThread();
+    final Optional<Long> optionalTotalExecutionTime = singleInfo.getTotalExecutionTime();
+
+    assertThat(optionalSubscribeOnThread.isPresent()).isFalse();
+    assertThat(optionalObserveOnThread.isPresent()).isFalse();
+    assertThat(optionalTotalExecutionTime.isPresent()).isFalse();
+  }
+
+  @Test
+  public void shouldReturnPresentValues() {
+    singleInfo.setSubscribeOnThread("thread");
+    singleInfo.setObserveOnThread("thread");
+    singleInfo.setTotalExecutionTime(1000);
+
+    final Optional<String> optionalSubscribeOnThread = singleInfo.getSubscribeOnThread();
+    final Optional<String> optionalObserveOnThread = singleInfo.getObserveOnThread();
+    final Optional<Long> optionalTotalExecutionTime = singleInfo.getTotalExecutionTime();
+
+    assertThat(optionalSubscribeOnThread.isPresent()).isTrue();
+    assertThat(optionalObserveOnThread.isPresent()).isTrue();
+    assertThat(optionalTotalExecutionTime.isPresent()).isTrue();
+  }
+}
\ No newline at end of file
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/SingleRule.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/SingleRule.java
new file mode 100644
index 0000000..2ad327c
--- /dev/null
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/internal/single/SingleRule.java
@@ -0,0 +1,63 @@
+package com.fernandocejas.frodo.internal.single;
+
+import com.fernandocejas.frodo.core.strings.Strings;
+import com.fernandocejas.frodo.internal.messenger.SingleMessageManager;
+import com.fernandocejas.frodo.joinpoint.FrodoProceedingJoinPoint;
+import com.fernandocejas.frodo.joinpoint.TestJoinPoint;
+import com.fernandocejas.frodo.joinpoint.TestProceedingJoinPoint;
+
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import rx.Single;
+
+class SingleRule implements TestRule {
+
+  static final String OBSERVABLE_STREAM_VALUE = "fernando";
+
+  private final Class declaringType;
+
+  private FrodoProceedingJoinPoint frodoProceedingJoinPoint;
+  private SingleInfo singleInfo;
+
+  @Mock
+  private SingleMessageManager messageManager;
+
+  SingleRule(Class declaringType) {
+    MockitoAnnotations.initMocks(this);
+    this.declaringType = declaringType;
+  }
+
+  @Override
+  public Statement apply(Statement statement, Description description) {
+    final TestJoinPoint testJoinPoint =
+            new TestJoinPoint.Builder(declaringType)
+                    .withReturnType(Single.class)
+                    .withReturnValue(OBSERVABLE_STREAM_VALUE)
+                    .build();
+    final TestProceedingJoinPoint testProceedingJoinPoint =
+            new TestProceedingJoinPoint(testJoinPoint);
+    frodoProceedingJoinPoint = new FrodoProceedingJoinPoint(testProceedingJoinPoint);
+    singleInfo = new SingleInfo(frodoProceedingJoinPoint);
+    return statement;
+  }
+
+  FrodoProceedingJoinPoint joinPoint() {
+    return frodoProceedingJoinPoint;
+  }
+
+  SingleMessageManager messageManager() {
+    return messageManager;
+  }
+
+  SingleInfo info() {
+    return singleInfo;
+  }
+
+  String stringType() {
+    return Strings.EMPTY;
+  }
+}
diff --git a/frodo-runtime/src/test/java/com/fernandocejas/frodo/joinpoint/TestProceedingJoinPoint.java b/frodo-runtime/src/test/java/com/fernandocejas/frodo/joinpoint/TestProceedingJoinPoint.java
index ea68ef0..fe7f8a0 100644
--- a/frodo-runtime/src/test/java/com/fernandocejas/frodo/joinpoint/TestProceedingJoinPoint.java
+++ b/frodo-runtime/src/test/java/com/fernandocejas/frodo/joinpoint/TestProceedingJoinPoint.java
@@ -5,7 +5,9 @@
 import org.aspectj.lang.reflect.MethodSignature;
 import org.aspectj.lang.reflect.SourceLocation;
 import org.aspectj.runtime.internal.AroundClosure;
+
 import rx.Observable;
+import rx.Single;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -31,6 +33,9 @@ private Object buildReturnType() throws InstantiationException, IllegalAccessExc
     if (returnType == Observable.class) {
       return Observable.just(testJoinPoint.getMethodReturnValue());
     }
+    if (returnType == Single.class) {
+      return Single.just(testJoinPoint.getMethodReturnValue());
+    }
     return returnType.newInstance();
   }
 
@@ -85,13 +90,6 @@ private Object buildReturnType() throws InstantiationException, IllegalAccessExc
     return testJoinPoint.getStaticPart();
   }
 
-  public Class getMethodReturnType() {
-    return testJoinPoint.getMethodReturnType();
-  }
-
-  public String getMethodReturnValue() {
-    return testJoinPoint.getMethodReturnValue();
-  }
 
   public void assertProceedMethodCalled() {
     assertThat(proceedMethodCalled).isTrue();
diff --git a/gradle.properties b/gradle.properties
index 6be72c3..07b2817 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -6,16 +6,16 @@ website=https://github.com/android10/frodo
 
 #Configuration
 androidBuildToolsVersion=2.1.0
-buildToolsVersion=23.0.3
+buildToolsVersion=25.0.0
 compileSdkVersion=23
 minSdkVersion=14
-targetSdkVersion=21
+targetSdkVersion=25
 bintrayPluginVersion=0.3.4
 
 #Dependencies
 annotationsVersion=13.0
 aspectjVersion=1.8.6
-rxJavaVersion=1.0.14
+rxJavaVersion=1.2.6
 
 #Test dependencies
 junitVersion=4.12
@@ -24,7 +24,7 @@ mockitoVersion=1.9.5
 robolectricVersion=3.0
 
 #Gradle Properties
-gradleVersion=2.12
+gradleVersion=3.4
 org.gradle.daemon=true
 org.gradle.parallel=true
 org.gradle.configureondemand=true