timber

A logger with a small, extensible API which provides utility on top of Android's normal Log class.

10,434

958

10,434

View on GitHub

Top Related Projects

logger

13,820

✔️ Simple, pretty and powerful logger for android

logback-android

1,198

📄The reliable, generic, fast and flexible logging framework for Android

Quick Overview

Timber is a logging library for Android that extends Android's default Log class. It provides a more powerful, flexible, and convenient way to handle logging in Android applications, with features like automatic tagging and the ability to plant custom tree implementations for logging.

Pros

Easy to set up and use with minimal configuration
Supports custom logging implementations through "Tree" objects
Automatically includes the calling class, method, and line number in log messages
Allows for easy debugging and release logging configurations

Cons

Limited to Android platform
May introduce a small performance overhead compared to native Android logging
Requires manual removal of debug logging calls for production releases if not configured properly
Limited built-in formatting options for log messages

Code Examples

Setting up Timber in your application:

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        if (BuildConfig.DEBUG) {
            Timber.plant(Timber.DebugTree())
        }
    }
}

Basic logging with Timber:

Timber.d("Debug message")
Timber.i("Info message")
Timber.e("Error message")

Logging with formatted strings and exceptions:

val user = "John"
Timber.d("User %s logged in", user)

try {
    // Some code that might throw an exception
} catch (e: Exception) {
    Timber.e(e, "An error occurred")
}

Getting Started

Add Timber to your project's dependencies:

dependencies {
    implementation 'com.jakewharton.timber:timber:5.0.1'
}

Initialize Timber in your Application class:

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        if (BuildConfig.DEBUG) {
            Timber.plant(Timber.DebugTree())
        }
    }
}

Use Timber for logging throughout your application:

Timber.d("Debug message")
Timber.i("Info message")
Timber.e("Error message")

Competitor Comparisons

logger

13,820

✔️ Simple, pretty and powerful logger for android

Pros of Logger

More customizable log formatting options
Built-in JSON and XML logging support
Includes a log file writer for easier file logging

Cons of Logger

Larger library size compared to Timber
Less integration with Android's built-in logging system
May require more setup and configuration

Code Comparison

Timber:

Timber.d("User logged in: %s", username)
Timber.e(exception, "Login failed")

Logger:

Logger.d("User logged in: %s", username)
Logger.e(exception, "Login failed")
Logger.json(jsonString)
Logger.xml(xmlString)

Both libraries offer similar basic logging functionality, but Logger provides additional methods for specific data types like JSON and XML. Timber's integration with Android's logging system makes it more lightweight and easier to use out of the box, while Logger offers more customization options at the cost of a larger library size and potentially more complex setup.

Timber is generally preferred for simpler logging needs and better Android integration, while Logger might be chosen for projects requiring more advanced logging features or extensive customization.

logback-android

1,198

📄The reliable, generic, fast and flexible logging framework for Android

Pros of logback-android

More configurable and flexible logging options
Supports various appenders (e.g., file, database, socket)
Compatible with SLF4J API, allowing easy integration with existing projects

Cons of logback-android

Larger library size and potential impact on app size
Steeper learning curve due to more complex configuration
Less Android-specific optimizations compared to Timber

Code Comparison

Timber:

Timber.d("Debug message")
Timber.e(exception, "Error message")

logback-android:

val logger = LoggerFactory.getLogger(MyClass::class.java)
logger.debug("Debug message")
logger.error("Error message", exception)

Summary

Timber is a lightweight, Android-specific logging library that's easy to set up and use. It provides simple, straightforward logging functionality with minimal configuration.

logback-android is a more comprehensive logging framework, offering greater flexibility and configuration options. It's better suited for complex logging requirements but may be overkill for simpler projects.

Choose Timber for quick, easy logging in Android apps, or logback-android for more advanced logging needs and compatibility with existing SLF4J-based projects.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

This is a logger with a small, extensible API which provides utility on top of Android's normal Log class.

I copy this class into all the little apps I make. I'm tired of doing it. Now it's a library.

Behavior is added through Tree instances. You can install an instance by calling Timber.plant. Installation of Trees should be done as early as possible. The onCreate of your application is the most logical choice.

The DebugTree implementation will automatically figure out from which class it's being called and use that class name as its tag. Since the tags vary, it works really well when coupled with a log reader like Pidcat.

There are no Tree implementations installed by default because every time you log in production, a puppy dies.

Usage

Two easy steps:

Install any Tree instances you want in the onCreate of your application class.
Call Timber's static methods everywhere throughout your app.

Check out the sample app in timber-sample/ to see it in action.

Lint

Timber ships with embedded lint rules to detect problems in your app.

TimberArgCount (Error) - Detects an incorrect number of arguments passed to a Timber call for the specified format string.

Example.java:35: Error: Wrong argument count, format string Hello %s %s! requires 2 but format call supplies 1 [TimberArgCount]
    Timber.d("Hello %s %s!", firstName);
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

TimberArgTypes (Error) - Detects arguments which are of the wrong type for the specified format string.

Example.java:35: Error: Wrong argument type for formatting argument '#0' in success = %b: conversion is 'b', received String (argument #2 in method call) [TimberArgTypes]
    Timber.d("success = %b", taskName);
                             ~~~~~~~~

TimberTagLength (Error) - Detects the use of tags which are longer than Android's maximum length of 23.

Example.java:35: Error: The logging tag can be at most 23 characters, was 35 (TagNameThatIsReallyReallyReallyLong) [TimberTagLength]
    Timber.tag("TagNameThatIsReallyReallyReallyLong").d("Hello %s %s!", firstName, lastName);
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

LogNotTimber (Warning) - Detects usages of Android's Log that should be using Timber.

Example.java:35: Warning: Using 'Log' instead of 'Timber' [LogNotTimber]
    Log.d("Greeting", "Hello " + firstName + " " + lastName + "!");
        ~

StringFormatInTimber (Warning) - Detects String.format used inside of a Timber call. Timber handles string formatting automatically.

Example.java:35: Warning: Using 'String#format' inside of 'Timber' [StringFormatInTimber]
    Timber.d(String.format("Hello, %s %s", firstName, lastName));
             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

BinaryOperationInTimber (Warning) - Detects string concatenation inside of a Timber call. Timber handles string formatting automatically and should be preferred over manual concatenation.

Example.java:35: Warning: Replace String concatenation with Timber's string formatting [BinaryOperationInTimber]
    Timber.d("Hello " + firstName + " " + lastName + "!");
             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

TimberExceptionLogging (Warning) - Detects the use of null or empty messages, or using the exception message when logging an exception.

Example.java:35: Warning: Explicitly logging exception message is redundant [TimberExceptionLogging]
     Timber.d(e, e.getMessage());
                 ~~~~~~~~~~~~~~

Download

repositories {
  mavenCentral()
}

dependencies {
  implementation 'com.jakewharton.timber:timber:5.0.1'
}

Documentation is available at jakewharton.github.io/timber/docs/5.x/.

Snapshots of the development version are available in Sonatype's snapshots repository.

repositories {
  mavenCentral()
  maven {
    url 'https://oss.sonatype.org/content/repositories/snapshots/'
  }
}

dependencies {
  implementation 'com.jakewharton.timber:timber:5.1.0-SNAPSHOT'
}

Snapshot documentation is available at jakewharton.github.io/timber/docs/latest/.

License

Copyright 2013 Jake Wharton

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Top Related Projects

logger

13,820

✔️ Simple, pretty and powerful logger for android

logback-android

1,198

📄The reliable, generic, fast and flexible logging framework for Android

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot