Unlock the Power of Debugging: Print Logs When API is Called in Android

Setting Up Logging in Android

Before we dive into printing logs when an API is called, let’s set up logging in Android. You can use the Android Log class or a third-party logging library like Timber or Logback.

Using the Android Log Class

The Android Log class provides a simple way to log messages at different levels (e.g., verbose, debug, info, warning, error). Here’s an example:

import android.util.Log;

public class MyActivity extends AppCompatActivity {
    private static final String TAG = "MyActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate called");
    }
}

Using Timber

Timber is a popular logging library for Android that provides a more concise and flexible way of logging. Here’s an example:

import timber.log.Timber;

public class MyActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Timber.d("onCreate called");
    }
}

Printing Logs When API is Called

Now that we’ve set up logging, let’s focus on printing logs when an API is called. We’ll use an example of making a GET request to a RESTful API using Retrofit.

Using Retrofit’s Built-in Logging

Retrofit provides built-in logging capabilities using the OkHttp logging interceptor. Here’s an example:

import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class ApiClient {
    private static Retrofit retrofit;

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
            logging.setLevel(HttpLoggingInterceptor.Level.BODY);
            OkHttpClient client = new OkHttpClient.Builder()
                    .addInterceptor(logging)
                    .build();

            retrofit = new Retrofit.Builder()
                    .baseUrl("https://api.example.com/")
                    .client(client)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }
}

In this example, we’re using the HttpLoggingInterceptor to log API requests and responses at the BODY level. This will print detailed logs of each API call.

Custom Logging with Interceptors

What if you want more control over logging or need to log specific data? You can create a custom interceptor to log API calls. Here’s an example:

import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;

public class ApiLoggingInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        long startTime = System.currentTimeMillis();
        Response response = chain.proceed(request);

        long endTime = System.currentTimeMillis();
        long duration = endTime - startTime;

        Timber.d("API Call: %s (%dms)", request.url(), duration);
        return response;
    }
}

In this example, we’re creating a custom interceptor that logs the API call URL and duration. You can add this interceptor to your OkHttp client:

OkHttpClient client = new OkHttpClient.Builder()
        .addInterceptor(new ApiLoggingInterceptor())
        .build();

Best Practices for Printing Logs When API is Called

Here are some best practices to keep in mind when printing logs when an API is called:

1. Log at the Right Level**: Log at the appropriate level (e.g., debug, info, warning, error) to ensure logs are useful and not overwhelming.
2. Log Relevant Data**: Log relevant data such as API call URLs, request and response bodies, and durations.
3. Use a Consistent Format**: Use a consistent format for logging API calls to make it easier to analyze and parse logs.
4. Log in a Centralized Location**: Log API calls in a centralized location, such as a logging dashboard or analytics platform, to make it easier to track and analyze logs.