Skip to content

Java SDK

This is the documentation for the Amplitude Analytics Java SDK. Note that this is not the Android SDK.

Ampli Wrapper versus the Amplitude SDK

The Ampli Wrapper is an autogenerated library based on your pre-defined tracking plan. The Ampli Wrapper is a lightweight wrapper over the Amplitude SDK that provides type-safety, supports linting, and enables features like input validation. The code replicates the spec in the Tracking Plan and enforces its rules and requirements. This guide is about Amplitude SDK. To learn more about Ampli Wrapper, see Ampli Wrapper Overview and examples.

SDK installation

Maven

Use Gradle or another build system to resolve the Java SDK dependency. The following example is for Gradle:

dependencies {
    implementation 'org.json:json:20201115'
    implementation 'com.amplitude:java-sdk:1.10.0'
}

Download (alternative)

Download the latest JAR file and add it to the project's buildpath. See instructions for your IDE.

EU data residency

Sending data to Amplitude's EU servers, you need to configure the server URL during the initialization.

Amplitude amplitude = Amplitude.getInstance();
amplitude.init("API KEY");
amplitude.setServerUrl("https://api.eu.amplitude.com/2/httpapi");

Usage and examples

Importing

Import Amplitude into any file that uses it. Amplitude uses the open source JSONObject library to conveniently create JSON key-value objects.

import com.amplitude.Amplitude;
import org.json.JSONObject;

Initialization

Initialization is necessary before any instrumentation is done. The API key for your Amplitude project is required.

Amplitude client = Amplitude.getInstance();
client.init("YOUR_API_KEY");

Amplitude.getInstance(String name) may optionally take a name which uniquely holds settings.

Amplitude client = Amplitude.getInstance("YOUR_INSTANCE_NAME");
client.init("YOUR_API_KEY");

Configure batching behavior

To support high performance environments, our SDK sends events in batches. Every event logged by logEvent method is queued in memory. Events are flushed in batch in background. You can customize batch behavior with setEventUpdloadThreshfold and setEventUploadPeriodMillis.

Amplitude client = Amplitude.getInstance();
// events queued in memory will flush when number of events exceed upload threshold
// default value is 10
client.setEventUploadThreshold(20);

// events queue will flush every certain milliseconds based on setting
// default value is 10,000 milliseconds
client.setEventUploadPeriodMillis(5000);

You can also flush events on demand.

client.flushEvents();

For customers who want to send large batches of data at a time, for example through scheduled jobs, rather than in a continuous real-time stream, Amplitude provides the batch mode. Both the regular mode and the batch mode use the same events upload threshold and flush time intervals, but the batch mode allows larger payload size(20MB) and has higher throttling limit. Due to the higher rate of data that's permitted by this mode, data sent by batch mode may be delayed based on load. You can see a usage example in this project on GitHub.

// Enable batch mode
client.useBatchMode(true);

// Disable batch mode
client.useBatchMode(false);

Config custom http proxy

New in version 1.9.0. Set and unset custom proxy for http requests.

// Set proxy for http requests
client.setProxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.domain.com", port)));

// Unset proxy
client.setProxy(Proxy.NO_PROXY);

Config custom logger

New in version 1.10.0. Set a customized logger for amplitude client.

// Set logger 
client.setLogger(new AmplitudeLog() {
  @Override
  public void log(String tag, String message, LogMode messageMode) {
    if (messageMode.level >= logMode.level) {
      // implement using custom logging framework and format
    }
  }
});

Config events flusing thread timeout

New in version 1.10.0. Set events flusing thread timeout in milliseconds. If set to a positive long integer, events flushing tasks will timeout and trigger callbacks for those events.

client.setFlushTimeout(2000L); // 2 seconds

Shutdown client and release resource

New in version 1.10.0. Stops the Amplitude client from accepting new events and shuts down the threadspool gracefully. Events in the buffer will trigger callbacks. A new instance is created and returned if you call Amplitude.getInstance(INSTANCE_NAME) with the same instance name.

client.shutdown();

Sending events

Important notes about sending events

This SDK uses the HTTP V2 API and follows the same constraints for events. Make sure that all events logged in the SDK have the event_type field and at least one of device_id or user_id, and follows the HTTP API's constraints on each of those fields.

To prevent instrumentation issues, device IDs and user IDs must be strings with a length of 5 characters or more. If an event contains a device ID or user ID that's too short, the ID value is removed from the event. If the event doesn't have a user_id or device_id value, the upload may be rejected with a 400 status. Override the default minimum length of 5 character by passing the min_id_length option with the request.

Events represent how users interact with your application. For example, "Button Clicked" may be an action you want to track.

Note

For testing Java SDK out, please make sure your main thread continues until the background daemon thread that has the Amplitude HTTP request is finished. Otherwise, the main thread terminated earlier than the daemon thread will lead logEvent to fail silently.

Amplitude client = Amplitude.getInstance();
client.logEvent(new Event("Button Clicked", "test_user_id"));

Events with properties

Events can also contain properties. They provide context about the event taken. For example, "hover time" may be a relevant event property to "button click."

Event event = new Event("Button Clicked", "test_user_id");

JSONObject eventProps = new JSONObject();
try {
  eventProps.put("Hover Time", 10).put("prop_2", "value_2");
} catch (JSONException e) {
  System.err.println("Invalid JSON");
  e.printStackTrace();
}

event.eventProperties = eventProps;

client.logEvent(event);

Set user properties

Privacy and tracking

Don't track any user data that may be against your privacy terms.

Use event.userProperties as a shorthand to set multiple user properties at one time.

Event event = new Event("Button Clicked", "test_user_id");

JSONObject userProps = new JSONObject();
double[] arr = {1,2,4,8};
try {
  userProps.put("team", "red").put("running_times", arr);
} catch (JSONException e) {
  e.printStackTrace();
  System.err.println("Invalid JSON");
}

event.userProperties = userProps;
client.logEvent(event);

Set device information

Unlike the Android SDK or iOS SDK, device information in Java SDK isn't collected via SDK. Device information like device id, device brand, device manufacturer, and device model can be set as properties in each event.

Event event = new Event("Button Clicked", "test_user_id");
event.deviceId = "device_id";
event.deviceBrand = "device_brand";
event.deviceManufacturer = "device_manufacturer";
event.deviceModel = "device_model";
client.logEvent(event);

Set session information

You can set sessionId in an event. This pattern also applies to other properties like city and price. You can see a full list of events properties in Event.java.

Event event = new Event("Button Clicked", "test_user_id");
event.sessionId = 1;
client.logEvent(event);

Amplitude callbacks

Support for AmplitudeCallBacks is available beginning with 1.4.0. You can trigger a callback when event is sent to server or failed after retries.

Amplitude client = Amplitude.getInstance();
AmplitudeCallbacks callbacks =
  new AmplitudeCallbacks() {
  @Override
    public void onLogEventServerResponse(Event event, int status, String message) {
    // Event: Event processed.
    // status: response code, like 200, 400, etc.
    // message: success or error message.
  }
};
client.setCallbacks(callbacks);

From 1.5.0, callbacks can be added to event level and triggered when the event is sent to server or failed after retries. One event can trigger both client level callbacks and event level callbacks.

Amplitude client = Amplitude.getInstance();
AmplitudeCallbacks eventCallbacks =
  new AmplitudeCallbacks() {
  @Override
    public void onLogEventServerResponse(Event event, int status, String message) {
    // Event: Event processed.
    // status: response code, like 200, 400, etc.
    // message: success or error message.
  }
};
client.logEvent(event, eventCallbacks)

Middleware

Middleware allows you to extend Amplitude by running a sequence of custom code on every event. This pattern is flexible and can be used to support event enrichment, transformation, filtering, routing to third-party destinations, and more.

Each middleware is a simple interface with a run method:

void run(MiddlewarePayload payload, MiddlewareNext next);

The payload contains the event being sent as well as an optional extra that allows you to pass custom data to your own middleware implementations.

To invoke the next middleware in the queue, use the next function. You must call next.run(payload) to continue the middleware chain. If a middleware doesn't call next, then the event processing stop executing after the current middleware completes.

Middleware is added to Amplitude via client.addEventMiddleware. You can add as many middleware as you like. Each middleware runs in the order in which it was added.

You can find examples for Java and Kotlin.

Troubleshooting

When debugging, check the logs. The SDK prints error messages.

If you have problems, open an issue on the GitHub issues page.


Last update: 2022-07-19