Skip to content
Entropy Data

SDK

The Entropy Data SDK is a Java library for building integrations that connect Entropy Data to your data platform. It is the foundation of the official Databricks, Snowflake, and BigQuery connectors, and you can use it to build the same for any platform.

An integration built on the SDK is a long-running application — typically a container in your own environment — that subscribes to the Entropy Data event feed and acts on the events in your data platform.

Common use cases:

  • Automate access — grant and revoke permissions when an access agreement is activated or deactivated, and report the provisioning outcome back.
  • Sync data products and assets — push metadata from the data platform into Entropy Data.
  • Publish cost and usage data.
  • Notify downstream consumers when data contract tests fail.

Install

The SDK is published to Maven Central. Requires Java 17+.

<dependency>
  <groupId>com.entropy-data</groupId>
  <artifactId>entropy-data-sdk</artifactId>
  <version>0.2.1</version>
</dependency>

Create a client

Authenticate with the host and an API key:

var client = new EntropyDataClient("https://api.entropy-data.com", apiKey);

The client exposes the resource APIs (client.getAccessApi(), client.getDataProductsApi(), client.getTeamsApi(), …) so you can read the resources referenced by an event and write results back.

Subscribe to events

Implement EntropyDataEventHandler and override only the events you care about — every callback has a default no-op, so an access-management integration overrides just the two access events:

public class AccessHandler implements EntropyDataEventHandler {

  private final EntropyDataClient client;

  public AccessHandler(EntropyDataClient client) {
    this.client = client;
  }

  @Override
  public void onAccessActivatedEvent(AccessActivatedEvent event) {
    // 1. create the grant in your data platform for this access
    // 2. report the outcome so Entropy Data reflects it
    client.getAccessApi().reportProvisioningSucceeded(event.getId(),
        new AccessProvisioningSucceededReport()
            .platform("my-platform")
            .reference("the-grant-you-created"));
  }

  @Override
  public void onAccessDeactivatedEvent(AccessDeactivatedEvent event) {
    // remove the grant, then report
    client.getAccessApi().reportDeprovisioningSucceeded(event.getId(),
        new AccessDeprovisioningSucceededReport().platform("my-platform"));
  }
}

Run the listener. It polls the feed in a loop and dispatches each event to your handler. A state repository remembers the last processed event, so a restart resumes where it left off:

var handler = new AccessHandler(client);
var stateRepository = new EntropyDataStateRepositoryRemote("my-connector", client);
var listener = new EntropyDataEventListener(
    "my-connector", "accessmanagement", client, handler, stateRepository);

listener.start();

Because delivery is at-least-once, make each action idempotent (create-if-not-exists, delete-if-exists), and — when several connectors share one feed — act only on the access agreements whose output port your integration owns. See Access provisioning for the reporting contract.

Learn more