Read more below the main new features as well as the key product enhancements that were released in Q3 of 2023!

NEW! Lightrun Support for Action Creation Across Multiple Sources !

Lightrun is excited to announce that developers can now select multiple agents and tags as a single source when creating an action directly from their IDEs. This option lets them simultaneously apply an action to a custom group of agents and tags, which improves their plugin experience and makes it easier to debug with multiple agents and tags. To learn more, see selecting multiple sources in VSCode and selecting multiple sources in JetBrains.

New! Enhanced Capability for Capturing High-Value Snapshot Actions

We’ve taken snapshot capturing to the next level by enabling you to now capture large values for Python and Node.js agents. As part of this enhancement, we’ve raised the default settings to accommodate larger string values. You can also define maximum limits in the agent.config file through the introduction of the max_snapshot_buffer_size, max_variable_size, and max_watchlist_variable_size fields. For more information, refer to the relevant Agent documentation: Python Agent Configuration and Node.js Agent Configuration.

NEW! Duplication of Actions from Within the IDE Plugins

Lightrun now offers an easy and more efficient way to insert Lightrun actions using ‘Copy and Paste’ within your JetBrains IDE, which allows developers to easily reuse existing actions in multiple locations within your code. This new functionality applies to all Lightrun action types, including Lightrun snapshots, metrics, and logs. It simplifies the task of reviving expired actions or duplicating actions which have non-trivial conditions and/or watch expressions.

Similarly, we’ve added a new Duplicate action within the VSCode IDE, which allows developers to easily reuse existing actions in multiple locations within their code. This new functionality applies to all Lightrun action types including Lightrun snapshots, metrics, and logs, simplyfying the task of creating non-trivial conditions and/or watch expressions.

NEW! PII Redaction per Agent Pool 

With the introduction of PII Redaction Templates, Lightrun now supports additional granularity for utilizing PII Redaction effectively. You can either establish a single default PII Redaction template to be applied to all your agents or alternatively create and assign distinct PII Redaction templates for different agent pools. For example, if you would like to apply PII Redaction only on a Production environment and not on Development or Staging.

To help you get started with configuring your PII redaction on Agent Pools, we provide a single Default template on the PII Redaction page which serves as a starting point for creating your templates. Note that it does not contain any predefined patterns and is not assigned to any agent pools. For more information, see Assigning PII Redaction templates to Agent Pools.

Feel free to visit Lightrun’s website to learn more or if you’re a newcomer, try it for free!

The post Lightrun’s Product Updates – Q3 2023 appeared first on Lightrun.

Lightrun for the Web is now supported in three different IDEs:

1. VS Code for the Web (https://vscode.dev) – a lightweight version of VS Code that runs fully in the browser and provides rich and powerful IDE capabilities without the need for any installation or configuration.
2. JetBrains Projector (https://lp.jetbrains.com/projector) – A self-hosted technology that runs IntelliJ-based IDEs and Swing-based apps on the server, allowing you access to them from anywhere using browsers and native apps.
3. code-server (https://github.com/coder/code-server) – A self-hosted version of VS Code, available for use either directly (when being spun up as a hosted service) or as an embedded IDE in 3rd party platforms. 

If you want to check out the individual plugins, check out the respective documentation articles:

1. vscode.dev
2. code-server

Lightrun’s users are now able to connect to their live applications directly from the browser, without having to download one of our dedicated plugins – and enjoy the full suite of Lightrun features right in the browser. Adding Logs, Snapshots and Metrics is fully supported in this integration, and the experience matches our desktop plugin experience one-to-one, with very minor limitations.

In addition, while using Lightrun for the Web all the security controls are enforced by the Lightrun Sandbox – a proprietary mechanism that ensures there no side effects happen or unexpected performance overhead is incurred while using Lightrun. The Lightrun Sandbox verifies the integrity, stability, and security of the instrumentation in real-time – ensuring no Lightrun Action can ever change the state of your application. 

If you choose to use VS Code for the web, note that it comes packed with useful extensions and capabilities, like a deep GitHub integration – that enables you to immediately open any GitHub repo in VSCode with a simple URL change – and Live Share which allow multiple developers now share the same IDE session and consume Lightrun Actions together, in the same view. This allows teams to conduct a quick and efficient joint investigation of complex and time-sensitive production issues.

With the newly-released support for Web IDEs, the Lightrun Dveloper Observability Platform combines the best of both worlds – a fully-packed, installation-free IDE environment in the browser, and the full suite of real-time, IDE-native observability capabilities to go along with it.

Start using Lightrun today, or request a demo to learn more.

The post Lightrun Is Now Available For Web IDEs appeared first on Lightrun.

Getting a good grasp on your application, especially when it is distributed across multiple clouds, kubernetes clusters and serverless functions is not an easy fit.

When trying to keep up with everything that’s going on inside the application, Dynatrace’s software intelligence observability solution is an excellent platform for helping developers and DevOps be alerted to the existence of issues on the infrastructure and application levels. Lightrun, the developer-native observability platform, helps practitioners go beyond the realm of static application telemetry – traditionally added during the application’s development phase – and enables the real-time extraction of line-by-line, debugger-grade information from live environments right inside Dynatrace.

In order to get the “full lay of the land” when things inevitably go wrong, it’s important to be able to access any level of granularity of information from all the relevant components that could have been the root cause of the issue at hand. There’s a term that refers to a system that enables its maintainers to achieve that level of comprehension: Observability. 

Observability is best defined as a property of a system – a system that is observable is built in a way that makes it possible to answer any question that might arise about the system without shipping any new code. An observable system is, of course, a great determining factor in whether we can troubleshoot tough bugs quickly and whether our system is considered reliable – faster resolution (usually measured as MTTR – mean time to resolve) is a great indicator for reliability.

When trying to understand what type of information an observable system can produce on its own, it’s best to think about the context where the value of such a system is most apparent – when we’re deep into complex troubleshooting sessions. When tackling tough issues, we often rely on two main types of telemetry data to clarify what is actually happening under the hood: Infrastructure-level information and application-level information. 

The integration between Dynatrace and Lightrun allows us to create full-cycle observability – which takes shape in the following form:

1. We’ll first use Dynatrace’s analysis and alerting capabilities to become aware of issues, then explore the existing information.This will give us a sense into how the machines running our application or the application itself is behaving, and will surface up various problems (like performance degradations).
2. Then, Developers and DevOps can use Lightrun from the IDE to add real-time, on-demand logs, metrics and traces to the running application – without stopping the application or shipping new code. 
3. The information provided by Lightrun is automatically collected by Dynatrace and can be consumed right next to information provided by Dynatrace itself – closing the aforementioned cycle.

Combining both tools to explore issues from various angles provides a level of visibility into the running application that is enough to solve many critical production issues and understand how the live application is behaving in real-time.

Check out this tutorial on how to use Dynatrace with Lightrun to get started.

The post Full-Cycle Observability With Dynatrace and Lightrun appeared first on Lightrun.

The Traditional DevOps Process

Here is a typical DevOps process:

This process flow needs no explanation. A DevOps team spins off this process into multiple pipelines, spanning different environments based on their DevOps strategy. A close look at this process flow makes it evident that it is designed to operate on a cyclical pattern, where the development side feeds the operations and back.

The DevOps Feedback Loop

The traditional DevOps process follows a linear flow suited for greenfield deployments when the software has less complexity. However, as complexity grows, there is a need to introduce feedback loops. In a DevOps process, there are two main types of feedback: feedback from developers to operations and from operations to developers.

Feedback from developers to operations informs the operations team about the state of the code and how it is progressing. This input helps operations plan for configuration changes in the upcoming release. On the other hand, feedback from operations to developers is used to provide information about the system’s performance. This information helps developers understand the runtime behavior of the system. 

But what if the system performance deteriorates significantly, or even worse, it breaks down completely? That’s where the linear progression of the DevOps process becomes inefficient.

Triaging DevOps Pipeline with Observability

Observability enables a software system’s internal functioning to be analyzed without introducing code changes. Furthermore, by embedding observability into the software’s DevOps pipeline, it is possible to triage the pipeline as per the severity of the system performance.

The Development vs. Operations Dilemma

The ability to triage a system performance issue brings a lot of clarity about the course of action. But executing those actions through the DevOps process has a few challenges. 

Operations Dilemma: Tweak the DevOps Pipeline for Release or Defects 

As we know, any DevOps practice has two fundamental principles, continuity and automation. Therefore, all DevOps processes are designed as continuous pipeline phases, which are automated based on developer actions or the result of previous pipeline steps.

This arrangement is ideal for executing new release cycles. However, addressing critical defects in production requires a quick turnaround, and the continuous pipeline progression poses a barrier. Also, the DevOps process cannot be automated to triage the pipeline based on the severity of production defects.

Developers Dilemma: Test in Production or Redeploy

Overcoming operational inefficiencies requires manual intervention based on close coordination between development and operations teams to test the defects in the production environment.  

Often, this coordination can be inefficient if, for example, developers need more information and seek to deploy the software in a different environment with repeated builds to analyze the issues.

Enter Continuous Observability: Developers Playground in Operations Arena

Continuous observability is a streamlined process that lets developers have complete visibility into the system’s internal state and identify issues as they happen. It augments the DevOps pipeline to provide runtime data captured across all phases of a pipeline without redeploying it.

The result: better visibility on system performance and shorter turnaround times in identifying defects. 

Continuous observability harmonizes the development and operations teams such that they collaborate more effectively. But, more importantly, it makes developers feel more at home by easing their workflow in a few ways.

Short-circuiting DevOps Processes for Production Debugging

Short-circuiting the DevOps cycle means that when a bug is found in production, the first step is to find the root cause directly in the production code. This approach eliminates the DevOps overheads of recreating the bug in non-production environments. 

Continuous observability allows the developers to explore the production software in runtime, thereby saving a lot of time and effort by bypassing the linear flow of DevOps processes for every fix.

DID YOU KNOW
Lightrun Platform supports plugins for popular IDEs such as Visual Studio Code,
IntelliJ, and PyCharm to let developers access the production code right from the
comfort of their favorite IDE without requesting DevOps to spin
off a separate environment.

Probing the Production Code for Live Debugging

Live debugging allows developers to see what is happening in the system in real-time and identify issues as they occur. This is achieved using dynamic logs. 

Continuous observability allows developers to troubleshoot live applications by dynamically adding logs anywhere in the application code. This way, they can probe all aspects of the code, such as internal states, variables, function parameters, and calls, to ask questions and get immediate answers through logs. Overall, this practice stands to have a positive impact on the Mean Time to Resolution (MTTR) for every bugfix.

DID YOU KNOW
With Lightrun, developers can add dynamic logs without relaunching the application
or releasing separate versions for debugging. Upon executing the code injected
with logs, the log output is immediately available on the IDE
and Lightrun console for further analysis.

Gathering Performance Metrics for Better Quality Assurance

Apart from troubleshooting, live debugging also lets developers capture performance metrics. These metrics are beneficial for profiling the production system on the fly.

With continuous observability, it is possible to build a real-time performance profile of production software by gathering important metrics, such as counts, timings, and other custom measurements, to identify poorly performing parts of the code. This capability can be further leveraged through data-driven insights to bring in predictive performance analysis of code deployment across all phases of the DevOps pipeline.

DID YOU KNOW
Lightrun can capture metrics across the entire breadth of the application code on
the fly to investigate impending performance issues. In addition,
Lightrun supports integrations with many APM platforms to export and chart
performance metrics thereby, helping to ensure quality assurance
of production software.

Take Charge of Your Production Debugging with Lightrun

If you feel your DevOps process is becoming a bottleneck for debugging production issues, then give Lightrun a try. Sign up for a free Lightrun account. You can refer to the Lightrun docs and get started with Java, Python or Node.js applications immediately.

The post How to Optimize the DevOps Pipeline Through Developer Workflows appeared first on Lightrun.