Know exactly when new exceptions and errors happen in production See the code and variable state for each error as if you were there See which IO and synchronized calls started taking longer (and why)

All your errors in one place

See everything. Configure nothing.

Takipi automatically collects caught/ uncaught exceptions and logged errors.

Stats and Trends

Know your dragons from your Goblins.

Takipi helps you prioritize errors. For each exception Takipi displays the following data: - Is it a new exception? - How many times it happened and has the rate increased/decreased compared to the previous deployment/day/week. - Is it coming from new code or code that has been modified lately? - Fail rate - how many times a method failed of the overall calls? - Caught/Uncaught

Call stacks with values

What was in my variables when the exception was thrown?

Takipi captures all the relevant variable and object values for any exception thrown within your app, so you don't have to stare at call stacks and guess which values were there.

Logs + (code and state) = Love

See code and state for any log error

For each error in your log get a link to the source and variable state at that moment. No more wishing a variable was logged.

Performance Decreases

When (and why) did this get slow?

See which IO and synchronized calls start taking longer, on average or cumulatively, and their variable values. Compare between deployments, timeframes and machines.

Built for production & CI

2% overhead. Zero configuration.

Takipi automatically detects when new code is deployed and breaks. No configuration or code changes required. Installs in 1 min.
  • Exception data and code are encrypted on your server using a 256 bit AES cipher.
  • They can only be opened by you using your privately issued encryption keys.


Takipi was built with extensive emphasis on the security of your data and code.

All data produced by Takipi on your server is encrypted using an AES-256 cipher. It can only be decrypted using a set of private AES encryption keys issued to you during installation. These keys are never stored on Takipi's servers and are only available to you.

Data Encryption

When an event such as an exception occurs within your app, Takipi collects the most relevant variable data and source code which caused it. The data is encrypted on your server using your installed encryption key before it's sent to Takipi in encrypted form. This includes both variable values and the source code on which they are shown. Data can only be decrypted by you locally using your private encryption key. You can generate AES encryption keys here.

Graph Analysis

To collect the most relevant variable data, Takipi performs a set of graph analyses to identify the most relevant variables and conditions triggering an exception within your app. As the JVM loads your Java/Scala, Takipi converts this bytecode into an abstract graph structure which does not contain symbols, values or operators. This structure is used to analyze exceptions and compile breakpoints you set.

Takipi removes all jar, package, class, field, method and variable names (for both your code and any Java or 3rd party frameworks). Takipi also removes all logical and numeric operators, number and string constants and code attributes. The resulting graph cannot be used to reverse-engineer or reveal application logic.

  • Takipi was built to run under extreme performance restrictions in production and staging.
  • You can directly control Takipi's CPU + RAM overhead.

Here's how Takipi works -

Code analysis

Takipi indexes and queries your code graph in the cloud to log only the most relevant variables and conditions (e.g. "log only when this variable is assigned null") - offloading this work from your servers.

Faster logging

Takipi dynamically generates custom algorithms to compress and log data for each exception in your app to get 10x faster logging compared to standard Java file logging.

In-memory logging

Takipi doesn't perform any IO calls (disk or network) from within your process. Data is placed directly in shared memory and is asynchronously encrypted and sent to Takipi's servers by a daemon process.


Takipi lets you dynamically control logging frequency to a CPU/RAM cap you select (between 2-5%) directly from the app's 'Servers' dialog.

Minimal bandwidth

Since Takipi only collects data directly related to an exception or breakpoint when they occur, it doesn't have to continuously upload data from your servers - keeping bandwidth use to a minimum.

Performance peaks

Takipi hard-limits the number of exceptions and breakpoints it collects at any given time to support even your most extreme performance peaks.

Garbage collection

Takipi's JVM agent is written in native C++ and Assembly and does not allocate Java objects or captures any reference to your own - helping ensure zero impact on your GC.

Installs in 1 min. Zero configuration. Built for production (2% overhead)

Free trial, no credit card required
Taki and Kipi