Stream android logcat output to an sd card

Question

I want to achieve the following but so far, no luck

• Open a file in the SD Card when the android application first started.
• Stream the logcat output to

Answer 1

I apologize if I am misunderstanding your goals, but perhaps you could use the java.util.logging API instead of using Logcat or the Android Logging mechanism.

Like the Android logging API, the java.util.logging API allows you to easily log messages at various levels, such as FINE, FINER, WARN, SEVERE, etc.

But the standard logging API has additional advantages, too. For example, you can easily create a log file by using a FileHandler. In fact, FileHandler has a built-in log rotation mechanism, so you don't have to worry (so much) about cleaning up the log files. You can also create a hierarchy of Loggers; so, for example, if you have two Loggers, com.example.foo and com.example.foo.bar, changing the logging level of the former will also change the logging level of the latter. This will even work if the two Loggers are created in different classes! Moreover, you change logging behavior at runtime by specifying a logging configuration file. Finally, you can customize the format of the log by implementing your own Formatter (or just use the SimpleFormatter to avoid the default XML format).

To use the standard logging API, you might try something like this:

    // Logger logger is an instance variable
    // FileHandler logHandler is an instance variable

    try {
        String logDirectory =
            Environment.getExternalStorageDirectory() + "/log_directory";

        // the %g is the number of the current log in the rotation
        String logFileName = logDirectory + "/logfile_base_name_%g.log";

        // ...
        // make sure that the log directory exists, or the next command will fail
        // 

        // create a log file at the specified location that is capped 100kB.  Keep up to 5 logs.
        logHandler = new FileHandler(logFileName, 100 * 1024, 5);
        // use a text-based format instead of the default XML-based format
        logHandler.setFormatter(new SimpleFormatter());
        // get the actual Logger
        logger = Logger.getLogger("com.example.foo");
        // Log to the file by associating the FileHandler with the log
        logger.addHandler(logHandler);
    }
    catch (IOException ioe) {
        // do something wise
    }

    // examples of using the logger
    logger.finest("This message is only logged at the finest level (lowest/most-verbose level)");
    logger.config("This is an config-level message (middle level)");
    logger.severe("This is a severe-level message (highest/least-verbose level)");

The Android logging mechanism is certainly easy and convenient. It isn't very customizable, though, and log filtering must be done with tags, which can easily become unwieldy. By using the java.uitl.logging API, you can avoid dealing with a multitude of tags, yet easily limit the log file to specific parts of your application, gain greater control over the location and appearance of the log, and even customize logging behavior at runtime.

Answer 2

Try manually setting a filter as described here: http://developer.android.com/guide/developing/debugging/debugging-log.html#filteringOutput

Something like:

logcat ActivityManager:I MyApp:V *:S

If you replace "MyApp" with the log tags that you are using, that should show you all info (and greater) logs from ActivityManager, and all verbose (and greater) logs from your app.

Answer 3

I repost my answer here so @JPM and others can see... The code basically just execute the logcat command and then build the log from the input stream.

final StringBuilder log = new StringBuilder();
try {        
    ArrayList<String> commandLine = new ArrayList<String>();
    commandLine.add("logcat");
    commandLine.add("-d");
    ArrayList<String> arguments = ((params != null) && (params.length > 0)) ? params[0] : null;
    if (null != arguments){
        commandLine.addAll(arguments);
    }

    Process process = Runtime.getRuntime().exec(commandLine.toArray(new String[0]));
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));

    String line;
    while ((line = bufferedReader.readLine()) != null){ 
        log.append(line);
        log.append(LINE_SEPARATOR); 
    }
} 
catch (IOException e){
        //
} 

return log;

Answer 4

I know this is a late answer to the question but I would highly recommend using Logback to write messages to a log file as well as the logcat.

1. Copy logback-android-1.0.10-2.jar and slf4j-api-1.7.5.jar to your libs folder.
2. Right-Click on both libs and from the menu select Build Path -> Add to Build Path.
3. Create a logback.xml file in your assets folder and enter the following:

  

  
  
    
      %msg
    
  

  
  
    
      WARN
    

    ${LOG_DIR}/log.txt

    
      %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
      
  

  
  
    
    
  

1. To write a log:

   public class MyActivity extends Activity { public static final Logger logger = LoggerFactory.getLogger(MyActivity.class);

   protected void onCreate(Bundle b)
   {
       super(b);
       try{
           throw new Exception("Test");
       }catch(Exception e){
           logger.error("Something bad happened",e);
       }
   }
   

   }