Redwood (Stanford CoreNLP API)

java.lang.Object
- edu.stanford.nlp.util.logging.Redwood

```
public class Redwood
extends Object
```
A hierarchical channel based logger. Log messages are arranged hierarchically by depth (e.g. main->tagging->sentence 2) using the startTrack() and endTrack() methods. Furthermore, messages can be flagged with a number of channels, which allow filtering by channel. Log levels are implemented as channels (ERROR, WARNING, etc). Details on the handlers used are documented in their respective classes, which all implement LogRecordHandler. New handlers should implement this class. Details on configuring Redwood can be found in the RedwoodConfiguration class. New configuration methods should be implemented in this class, following the standard builder paradigm. There is a tutorial on Redwood on the NLP website.

Author:

Gabor Angeli (angeli at cs.stanford), David McClosky

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Redwood.ConsoleHandler` Default output handler which actually prints things to the real System.out
`static class`	`Redwood.FileHandler` Handler which prints to a specified file TODO: make constructors for other ways of describing files (File, for example!)
`protected static class`	`Redwood.Flag` Standard channels; enum for the sake of efficiency
`static class`	`Redwood.Record` A log record, which encapsulates the information needed to eventually display the enclosed message.
`protected static class`	`Redwood.RecordHandlerTree` A tree structure of record handlers
`static class`	`Redwood.RedwoodChannels` Represents a collection of channels.
`static class`	`Redwood.Util` A utility class for Redwood intended for static import (import static edu.stanford.nlp.util.logging.Redwood.Util.*;), providing a wrapper for Redwood functions and adding utility shortcuts

Field Summary

Fields
Modifier and Type	Field and Description
`static Redwood.Flag`	`DBG`
`static Redwood.Flag`	`ERR`
`static Redwood.Flag`	`FORCE`
`protected static PrintStream`	`realSysErr` The real System.err stream
`protected static PrintStream`	`realSysOut` The real System.out stream
`static Redwood.Flag`	`STDERR`
`static Redwood.Flag`	`STDOUT`
`static boolean`	`supportsAnsi`
`static Redwood.Flag`	`WARN`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`protected static void`	`captureSystemStreams(boolean captureOut, boolean captureErr)` Captures System.out and System.err and redirects them to Redwood logging.
`static Redwood.RedwoodChannels`	`channels(Object... channelNames)` Create an object representing a group of channels.
`protected static void`	`clearHandlers()` Remove all log handlers from Redwood, presumably in order to construct a custom pipeline afterwards
`static void`	`endThreads(String check)` Signal that all threads have run to completion, and the multithreaded environment is over.
`static void`	`endTrack()` A utility method for closing calls to the anonymous startTrack() call.
`static void`	`endTrack(String title)` End a "track;" that is, return to logging at one level shallower.
`static void`	`finishThread()` Signal that this thread will not log any more messages in the multithreaded environment
`static void`	`forceTrack()` Helper method to start an anonymous track on the FORCE channel.
`static void`	`forceTrack(Object name)` Helper method to start a track on the FORCE channel.
`static String`	`formatTimeDifference(long diff)`
`protected static void`	`formatTimeDifference(long diff, StringBuilder b)` Utility method for formatting a time difference (maybe this should go to a util class?)
`static void`	`hideChannelsEverywhere(Object... channels)` Hide multiple channels.
`static void`	`log(Object... args)` Log a message.
`static void`	`logf(String format, Object... args)` The Redwood equivalent to printf().
`static void`	`main(String[] args)` Various informal tests of Redwood functionality
`protected static void`	`restoreSystemStreams()` Restores System.out and System.err to their original values
`protected static Redwood.RecordHandlerTree`	`rootHandler()`
`static void`	`startThreads(String title)` Start a multithreaded logging environment.
`static void`	`startTrack(Object... args)` Begin a "track;" that is, begin logging at one level deeper.
`static void`	`stop()` Stop Redwood, closing all tracks and prohibiting future log messages.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - ERR
```
public static final Redwood.Flag ERR
```
  - WARN
```
public static final Redwood.Flag WARN
```
  - DBG
```
public static final Redwood.Flag DBG
```
  - FORCE
```
public static final Redwood.Flag FORCE
```
  - STDOUT
```
public static final Redwood.Flag STDOUT
```
  - STDERR
```
public static final Redwood.Flag STDERR
```
  - realSysOut
```
protected static final PrintStream realSysOut
```
    The real System.out stream
  - realSysErr
```
protected static final PrintStream realSysErr
```
    The real System.err stream
  - supportsAnsi
```
public static final boolean supportsAnsi
```
- Method Detail
  - rootHandler
```
protected static Redwood.RecordHandlerTree rootHandler()
```
  - clearHandlers
```
protected static void clearHandlers()
```
    Remove all log handlers from Redwood, presumably in order to construct a custom pipeline afterwards
  - captureSystemStreams
```
protected static void captureSystemStreams(boolean captureOut,
                                           boolean captureErr)
```
    Captures System.out and System.err and redirects them to Redwood logging.
    
    Parameters:
    
    captureOut - True is System.out should be captured
    
    captureErr - True if System.err should be captured
  - restoreSystemStreams
```
protected static void restoreSystemStreams()
```
    Restores System.out and System.err to their original values
  - log
```
public static void log(Object... args)
```
    Log a message. The last argument to this object is the message to log (usually a String); the first arguments are the channels to log to. For example: log(Redwood.ERR,"tag","this message is tagged with ERROR and tag")
    
    Parameters:
    
    args - The last argument is the message; the first arguments are the channels.
  - logf
```
public static void logf(String format,
                        Object... args)
```
    The Redwood equivalent to printf().
    
    Parameters:
    
    format - The format string, as per java's Formatter.format() object.
    
    args - The arguments to format.
  - startTrack
```
public static void startTrack(Object... args)
```
    Begin a "track;" that is, begin logging at one level deeper. Channels other than the FORCE channel are ignored.
    
    Parameters:
    
    args - The title of the track to begin, with an optional FORCE flag.
  - forceTrack
```
public static void forceTrack(Object name)
```
    Helper method to start a track on the FORCE channel.
    
    Parameters:
    
    name - The track name to print
  - forceTrack
```
public static void forceTrack()
```
    Helper method to start an anonymous track on the FORCE channel.
  - endTrack
```
public static void endTrack(String title)
```
    End a "track;" that is, return to logging at one level shallower.
    
    Parameters:
    
    title - A title that should match the beginning of this track.
  - endTrack
```
public static void endTrack()
```
    A utility method for closing calls to the anonymous startTrack() call.
  - startThreads
```
public static void startThreads(String title)
```
    Start a multithreaded logging environment. Log messages will be real time from one of the threads; as each thread finishes, another thread begins logging, first by making up the backlog, and then by printing any new log messages. A thread signals that it has finished logging with the finishThread() function; the multithreaded environment is ended with the endThreads() function
    
    Parameters:
    
    title - The name of the thread group being started
  - finishThread
```
public static void finishThread()
```
    Signal that this thread will not log any more messages in the multithreaded environment
  - endThreads
```
public static void endThreads(String check)
```
    Signal that all threads have run to completion, and the multithreaded environment is over.
    
    Parameters:
    
    check - The name of the thread group passed to startThreads()
  - channels
```
public static Redwood.RedwoodChannels channels(Object... channelNames)
```
    Create an object representing a group of channels. Redwood.RedwoodChannels contains a more complete description.
    
    See Also:
    
    Redwood.RedwoodChannels
  - hideChannelsEverywhere
```
public static void hideChannelsEverywhere(Object... channels)
```
    Hide multiple channels. All other channels will be unaffected.
    
    Parameters:
    
    channels - The channels to hide
  - stop
```
public static void stop()
```
    Stop Redwood, closing all tracks and prohibiting future log messages.
  - formatTimeDifference
```
protected static void formatTimeDifference(long diff,
                                           StringBuilder b)
```
    Utility method for formatting a time difference (maybe this should go to a util class?)
    
    Parameters:
    
    diff - Time difference in milliseconds
    
    b - The string builder to append to
  - formatTimeDifference
```
public static String formatTimeDifference(long diff)
```
  - main
```
public static void main(String[] args)
```
    Various informal tests of Redwood functionality
    
    Parameters:
    
    args - Unused

Class Redwood

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ERR

WARN

DBG

FORCE

STDOUT

STDERR

realSysOut

realSysErr

supportsAnsi

Method Detail

rootHandler

clearHandlers

captureSystemStreams

restoreSystemStreams

log

logf

startTrack

forceTrack

forceTrack

endTrack

endTrack

startThreads

finishThread

endThreads

channels

hideChannelsEverywhere

stop

formatTimeDifference

formatTimeDifference

main