How Lightrun Works
Traditionally, exceptions, logs, performance metrics and traces have always been defined during the development stage. With the advent of the cloud, followed by microservices and serverless architectures, a gap was created between development and the production environment, making it nearly impossible to anticipate production-only issues or reproduce them.
Lightrun is the first platform to shift observability left, empowering developers with 100% visibility into their code regardless of environment or deployment type, from monolith to microservices. With Lightrun, developers have easy access to exceptions as they occur, and they securely add logs, metrics and traces to production and staging in real time, on demand.
Lightrun is integrated into the developer workflow, from the IDE to APMs and logging tools; all instrumentation is added from the IDE you’re already using and directly to your running application, eliminating the need to predict every edge case imaginable or reproduce environments that can’t be reproduced, by enabling you to check issues on the fly.
With this perspective into your code, you can troubleshoot, test and debug your application by investigating issues directly from the environments in which they're running, while they're running, including the development, staging and production environments.
Read more about:
Lightrun comprises these parts:
- Management Server - this is the Lightrun server, responsible for service management; this is the fundamental "backbone" of the platform. With our SaaS deployment, Lightrun manages this side of things; all you need to do is install and run the Lightrun agents within your live apps.
- Java Agent - the JVMTI agent that runs alongside the application on your application servers; this agent dynamically inserts the logs, metrics and snapshots in the code based on the Lightrun actions you run.
- Client - the IDE plugin and command line utility; you can use either of these in order to add, remove and modify actions - whichever is part of your natural workflow. Whenever you run a command to insert an action, the agent receives your request and adds those actions accordingly.
These three components communicate with one another as illustrated in the following diagram:
How it works¶
Using Lightrun actions from your IDE, Lightrun enables you to add logs, metrics and more on-the-fly directly in to your already-compiled source code for the live application - in any environment.
Whenever you send a Lightrun action to be added, the inserted code is run in a dedicated sandbox before being added to your application. The Lightrun Sandbox validates there are no side effects to your application’s behavior, and it verifies integrity, stability and security of the instrumentation. Lightrun Sandbox guarantees no exceptions, system I/O, system calls or state/flow changes, and only read-only code is ever added to your running application.
Once you've added the action, you can immediately view the output directly from the IDE as well, or from the web interface in any browser.
This is how it works:¶
Configure the agent. The stateless Lightrun agent is the heart of the Lightrun product.
Optionally, customize agent configuration, such as to enable exceptions to be handled through Lightrun as well.
Add the agent to the running application. This small library then connects to the Lightrun Management Server, managing communications with the IDE plugin, with the Management Server and with your application through HTTPS.
Install the plugin and authenticate it.
Add Lightrun actions into the relevant lines of code, on-the-fly. Lightrun actions include:
- Logs - Metrics - Snapshots - virtual breakpoints that don't stop the app
When user actions are received, the Lightrun Management Server sends the request to the agent. The agent checks the requested actions through our proprietary sandbox, and once integrity, stability and security are verified, it adds instrumentation to your application during runtime, immediately.
Watch this video for more information: