All Your Errors In One Place

See everything. Configure nothing.

Takipi detects all caught and uncaught exceptions, logged and HTTP errors. View screenshot

Stats and Trends

Quickly prioritize every error with deep analytics

  • Is it new?
  • When did it start?
  • How often is it happening?
  • Is it coming from new or modified code?
  • Has it increased in the past hour, day, week?

Source and State

See the source and variables behind every error

Takipi captures the source code and variable values behind every error in your application, across threads and machines. View screenshot

Smarter Logs and Traces

Get to the cause right from your logs

Jump into the analytics, code and variables behind every log error with Powerlinks. No more wishing a variable was logged - your stack traces just became 10x smarter.

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.

Overview

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.

CPU & RAM

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)

Try it out
Free trial, no credit card required
Taki and Kipi