Re: a simpler logger [?]

[Mark Wielaard <mark at klomp dot org>]

Hi Phil,

On Tue, 2008-02-12 at 12:23 +0000, Phil Muldoon wrote:
> As fine.caller() is an optional call (you have to supply it in the 
> arguments), the overhead of the Throwable can be managed by the 
> programmer. Personally I find it immensely useful to detect the origin 
> of a call. I would like to see it the Log code.

Thanks. Attached is what I will most likely push, unless you find any
troubles while testing with it.

Cheers,

Mark

commit d9c5abf617a6157c7df7db340f8f9fdb9b42e538
Author: Mark Wielaard <mwielaard@redhat.com>
Date:   Tue Feb 12 14:18:08 2008 +0100

    Add caller() and callers() methods to rsl Log.
    
    frysk-sys/frysk/rsl/ChangeLog
    2008-02-12  Mark Wielaard  <mwielaard@redhat.com>
    
            * Log.java (caller): New public method.
            (empty): New private empty String[].
            (callersArray): New private method.
            (callers): New public method.
            (callers(int)): New public method.

diff --git a/frysk-sys/frysk/rsl/ChangeLog b/frysk-sys/frysk/rsl/ChangeLog
index a2997cf..2b84755 100644
--- a/frysk-sys/frysk/rsl/ChangeLog
+++ b/frysk-sys/frysk/rsl/ChangeLog
@@ -1,3 +1,11 @@
+2008-02-12  Mark Wielaard  <mwielaard@redhat.com>
+
+	* Log.java (caller): New public method.
+	(empty): New private empty String[].
+	(callersArray): New private method.
+	(callers): New public method.
+	(callers(int)): New public method.
+
 2008-02-11  Andrew Cagney  <cagney@redhat.com>
 
 	* Log.java (prefixTime()): Print time in DAY HH:MM:SS.mmm format;
diff --git a/frysk-sys/frysk/rsl/Log.java b/frysk-sys/frysk/rsl/Log.java
index 1ddfa73..e77aaed 100644
--- a/frysk-sys/frysk/rsl/Log.java
+++ b/frysk-sys/frysk/rsl/Log.java
@@ -420,4 +420,75 @@ public final class Log {
 	    return;
 	prefix(self); print(p1); print(p2); print(p3); print(p4); print(p5); print(p6); suffix();
     }
+
+  /**
+   * Convenience method to get the caller of a method in which you
+   * use the Log object. Returns the caller (of the caller) of this
+   * method as String or "<unknown>" if caller cannot be found or if
+   * logger isn't logging. Use as:
+   * <code>log.log(this, "method called by ", log.caller());</code>.
+   */
+  public String caller()
+  {
+    if (logging)
+      {
+	Throwable t = new Throwable();
+	StackTraceElement[] stackTrace = t.getStackTrace();
+	if (stackTrace.length > 2)
+	  return stackTrace[2].toString();
+      }
+
+    return "<unknown>";
+  }
+
+  // Empty caller array for use in callersArray.
+  static private final String[] empty = new String[0];
+
+  // Private method that should only be directly called from
+  // callers() or callers(int), which in turn should only be called
+  // directly from the method that uses the Log and wants to find
+  // its callers. Depends on actual caller being of depth 3.
+  private String[] callersArray(int max)
+  {
+    if (logging)
+      {
+        Throwable t = new Throwable();
+        StackTraceElement[] stackTrace = t.getStackTrace();
+	int length = stackTrace.length > 3 ? stackTrace.length - 3 : 0;
+	if (length > max)
+	  length = max;
+	String[] callers = new String[length];
+        while (length > 0)
+	  {
+	    callers[length - 1]
+	      = stackTrace[length + 2].toString();
+	    length--;
+	  }
+	return callers;
+      }
+
+    return empty;
+  }
+
+  /**
+   * Convenience method to get an array of callers of a method in
+   * which you use the Log object. Returns the callers (of the caller)
+   * of this method as a String[] or an empty array if the callers
+   * cannot be found or if logger isn't logging. Use as:
+   * <code>log.log(this, "method called by ", log.callers());</code>.
+   * This is pretty heavyweight when the Log is enabled, so use
+   * sparingly.
+   */
+  public String[] callers()
+  {
+    return callersArray(Integer.MAX_VALUE);
+  }
+
+  /**
+   * Same as callers() but only returns at most max callers.
+   */
+  public String[] callers(int max)
+  {
+    return callersArray(max);
+  }
 }