Real-time Debugging from Dev to Production
From monolith to microservices and serverless
- Developers can now add logs and metrics in real-time even while the service is running.
- Service owners, I&Os and SREs gain faster reaction to production issues.
- Easily debug monolith microservices, Kubernetes, Docker Swarm, ECS, Big Data workers, serverless, and more.
No more local reproduction of environments, restarts or redeployments. Skip the traditional CI/CD pipelines to identify and resolve bugs faster, more easily and with less downtime. Improve customer experience immediately
Continuous Debugging Agility
Insert logs, snapshots and performance metrics to the live app. Add as many as you need. Extract variables, values, performance metrics, arguments and more without releasing a new version.
Save developers the time and headaches to let them focus on what really matters – developing. Hours and days spent issuing hotfixes, restarting, redeploying and reproducing locally turn into coding time.
Security and Stability
On-premise installation or in the cloud, Lightrun assures organizations the security and privacy of their code. Enterprise-level security measures: ISO 27001 certification, encryptions, RBAC and SSO, audit trail and logs and privacy blacklisting.
Lightrun operates everywhere and anywhere: on-premise, in the cloud (AWS, GCP, Azure), for microservices, for serverless, K8, and more. Debug in any environment across any infrastructure.
Lightrun’s footprint is negligible. The invocation requires a minimal footprint ranging from tens of μs to hundreds. To ensure overhead control, we use quotas to impose usage limits. A built-in sandbox prevents state modifications.
Covering all your debugging needs:
We’ve all felt the frustration and irritation of missing a log in the exact place we needed one. No more. Just add a log in real-time. No need to release a new version to see the log data.
- Troubleshoot live applications easily by dynamically adding logs lines
- Add as many logs as you need until you identify the problem
- Use the same IDE you’re already working on
- Evaluate any Java expression
- Supporting conditional logs
- Multi-instance support (microservices, big data workers) using a tagging mechanism
- Explore and inspect in the log analysis tool of your choice: DataDog, Splunk, Elastic, etc. under the context of existing logs
- Or, print the log data straight in your IDE and analyze your code behavior locally
- Adding logs is as easy as pie
When you need to explore your stack trace and variables comprehensively, add a Lightrun snapshot in real-time and on-demand. This virtual breakpoint extracts all the data you need for investigating without breaking the system.
- Explore the call stack and local variables in any location in the code in the same version they occurred in
- Traverse the stack just like a regular breakpoint
- Need more snapshots? Add as many as you need. You’re not breaking the system.
- Watch Expressions can also be added
- Conditional snapshots supported
- Tagging mechanism enables multi-instance support (microservices, big data workers)
- Add snapshots in the IDE you’re already using, easily
When you need to measure the performance and synchronization of your code, add metrics in real-time. Monitor and measure immediately to find bottlenecks without affecting system performance.
- Add metrics until you identify the performance issue while the app is running
- Add performance metrics like: counters, timers, function durations, custom metrics and more on-demand
- Count line execution occurrences
- Measure the execution time between any two code lines
- Collect system stats like latency and throughput through counters and timers
- Supporting conditional metrics
- Supporting multi-instances (microservices, big data workers) with a tagging mechanism
- Pipe the data into the APMs and monitoring solutions of your choice: New Relic, DynaTrace, DataDog, AppDynamics, StatsD, Prometheus and more to get performance alerts and visualization
- Find performance and synchronization issues easily in the same version you released and without slowing down
Ready to get started?
Lightrun operates on-prem, cloud, with microservices and serverless.
Data Viewing and Consumption
Lightrun is integrated into the developer workflow, from the IDE to the logging tools and APMs.
- Use Lightrun to debug through the IDE you’re already using and familiar with for reading and troubleshooting source code.
- Use Lightrun to pipe the data into the APMs and logging tools you already use and love.
- View and consume application data in your IDE or in APMs
and logging tools (or both)
We Integrate With Your Logging and APM Solutions
Lightrun is integrated into the developer workflow, from the IDE to the logging tools and APM.
We support multiple integrations to ensure your development and debugging process is frictionless.
Connect to the tool of your choice: DataDog, New Relic, Splunk, AppDynamics, DynaTrace, Prometheus, StatsD, and more.
- Pipeline the data to your favorite data analysis or monitoring tool
- Search through your log analysis tool together with the rest of your logs
- View and consume application data in your IDE or in APMs and logging tools (or both)
One of the debugging challenges developers encounter today is debugging multi-instances sharing the same code base, like microservices, K8 and Big Data workers.
Debug Kubernetes, Docker Swarm, ECS and more through Lightrun tagging.
Populate logs or metrics for multiple instances.
Cover a complete set of instances in one go.
Stability and Performance
The external state has to remain untouched. To ensure the system doesn’t collapse, the inserted code is run in a dedicated Sandbox. A problematic code isn’t added. We guarantee no exceptions.
The performance footprint ranges from tens of μs hundreds per invocation. In idle mode it has no overhead. To ensure control, we use quotas to impose usage limits. When the quota is reached, actions are disabled.
As experienced cyber security experts, Lightrun is committed to enterprise-grade security standards. ISO 27001 compliant, we ensure your code and data are kept safe and private.