Lightrun’s LogOptimizer stands as a groundbreaking automated solution for log optimization and cost reduction in logging. An integral part of the Lightrun IDE plugins, this tool empowers developers to swiftly scan their source code—be it a single file or entire projects—to identify and replace log lines with Lightrun’s dynamic logs, all within seconds. Compatible with runtimes such as Java, JavaScript, and Python, the LogOptimizer is a game-changer in enhancing logging efficiency

With the LogOptimizer, developers can benefit from the following:

• Get in few minutes visibility into low quality logs that aren’t required as part of your source code
• Reduce the noise in your logs and the overall cost of logging and shift left FinOps practices toward engineers
• Move away from using static logs toward dynamic logging
• Establish a continuous optimized process of log optimization as part of your DevOps practice
• Reduce the noise generated with over-logging (e.g. Static logs, marker logs, duplicate logs, etc.), and find the most valuable information in a cleaner code

What’s New

With the release of Lightrun 1.23.1, significant improvements have been made to enhance user experience and streamline the process of optimizing logs and reducing costs. The product has been thoughtfully restructured into user-friendly sections, making it easier for developers to navigate and seamlessly manage log optimization workflows. In the updated version, developers now have a clear and accessible list of findings from the LogOptimizer scan on the left side of the product. They can effortlessly explore each finding or choose a specific source code file for a more focused analysis. On the right side of the LogOptimizer window, integrated within the IDE plugin, developers receive a convenient summary of the scan, providing a valuable high-level overview with results categorized by file numbers and the total number of findings

To get started with Lightrun LogOptimizer you should make sure that the Docker desktop client is installed and running on your machine. Once it does, from the Lightrun IDE plugin you can run a single source file scan or an entire project scan. See the below quick demo to learn more.

Bottom Line

As organizations try to shift left FinOps towards developers and reduce the overall spend, such tools can empower developers to be more knowledgeable as well as accountable for their software development ongoing costs. As a recurring insight coming from the annual FinOps foundation report, the top challenge (over 32% of responses) with cloud computing cost reduction is the empowerment of developers to take action based on data for their spend.

To get started with Lightrun and the LogOptimizer, please refer to our documentation as well as visit https://lightrun.com and/or book a demo!

The post Lightrun LogOptimizer Gets A Developer Productivity and Logging Cost Reduction Boost appeared first on Lightrun.

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.

When it comes to debugging performance related issues, the range of these issues together with their root cause can be overwhelming to developers. 

Resolving performance issues is a challenging task due to the multitude of potential factors that can contribute to their occurrence. These factors range from inefficient code or architecture that lacks scalability, to specific infrastructure problems related to hardware and storage. Additionally, reproducing performance issues in a local environment that mimics the production setup can be difficult, as well as identifying and addressing these issues for specific sets of users. Developers often encounter these common challenges when attempting to resolve performance problems. Furthermore, developers may also face a lack of expertise in utilizing Application Performance Monitoring (APM) tools, which, in any case, may not offer code-level insights and actionable information.

For developers who want to address code-specific inquiries when troubleshooting performance issues, such as: 

• Determining how many times a particular line of code is executed 

• Whether a specific line of code is reached

• The execution time of a method

• The execution time of a code block

Pinpointing the exact lines of code responsible for downtime or performance problems can be a challenging and intimidating task. Moreover, identifying performance anomalies within a specific area of the product becomes exceedingly difficult without access to comprehensive insights and meaningful correlations between metrics obtained from various sources, such as the database, CPU usage, network latency, and so on.

Marketplace Gap

While the APM and profiling marketplace today is extremely advanced and offers a range of tools and solutions for monitoring and alerting the developers and Ops when a degraded service occurs, these tools are not operating within the source code or the IDE itself, and requires the developers to be very well versed in these tools and domain instead of him focusing on the code areas that are causing these issues. Having the ability to combine APM tools and dashboards with a developer native observability solution is a perfect bridge to the existing gap and the above-mentioned challenges. That was the rationale behind launching the advanced Lightrun Metrics for performance observability and debugging.

Solution Overview

When trying to address the above mentioned gaps as well as challenges, Lightrun Metrics comes to focus on the following 4 use cases and shift left performance observability:

It does so by providing developers with 4 key metrics that are being collected and consumed within the Java IntelliJ IDE as well as piped to leading APM tools dashboards.

4-type Metrics Collection

The Lightrun Metrics dedicated tab within the IDE plugin consists of the following:

Counters* (coming Soon), TicToc, Method Duration, and Custom Metrics. Below are some details on what each of these provide.

• Counters

A Lightrun Counter is added to a single line of code. It counts the number of times the code line is reached. You can add a counter to any and as many lines of code you need. From the Lightrun IDE plugin, you can specify the conditions (as Boolean expressions) when to record the line execution

• TicToc (Block Duration)

The Lightrun Tic & Toc metric measures the elapsed time for executing a specified block of code, within the same function

•  Method Duration

The Method Duration metric measures the elapsed time for executing a given method

•   Custom Metric

Lightrun metrics enables developers to design their own custom metric, using conditional expressions that evaluate to a numeric result of type long. Custom metrics are all about value distribution and correctness within a given Java application, and it allows developers to transform a specific variable value into statistics and detect anomalies or other distribution trends. Custom metrics can be created using the configuration form in the Lightrun IDE plugin. 

Example/How To Use

To get started with Lightrun Metrics, developers would need to create a new Lightrun account and install the IntelliJ dedicated plugin. Once the setup is complete developers can start creating metrics across the 4 types highlighted above. Here are examples of the creation and understanding of them.

Note that you can use the Lightrun actions against a single application instance or a few based on the amount of agents attached to these instances and collect metrics and averages.

TicToc

To add a TicToc and measure a block of code execution duration, go to the Lightrun plugin within the IntelliJ IDE and right click the line of code to add the specific action.

As you can see in the above screenshot, developers can gain runtime code-level execution performance within the TicToc graph and examine averages across deployments and over time.

Custom Metric

To build a custom expression around the code under investigation, go to the Lightrun plugin within the IntelliJ IDE and right click the line of code to add this specific action.

Visualizing the action output within 3rd party tools can be done through our various integrations and by setting the target output within the IDE plugin user interface.

Below is a complete demo video that shows the entire solution and the different metric options used in a Java application that’s running with 20 agents attached.

Bottom Line

Shifting left developer observability and employing the observability driven development workflow can be much easier through such tools and capabilities. When developers are better equipped with tools that fit their skillset and that operate from within their native environments, they are much more productive, hence, can resolve the issues at hand much faster. They can specifically analyze performance issues from the code level and reduce the overall MTTR for such issues, and they can do so by not having to change the application state since these actions are all added and consumed in runtime. 

Get Started with Lightrun Metrics!

The post Lightrun Empowers Developers with Next Generation Metric Tools for Java Performance Troubleshooting appeared first on Lightrun.

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

NEW! Lightrun Support for Troubleshooting .NET Applications !

Lightrun extended its runtime support with the addition of .NET applications debugging. With this new capability, developers can troubleshoot live applications directly from the VSCode, VSCode.dev, and JetBrains Rider IDE plugins and resolve issues quickly. The support for .NET runtime also enhances the depth of troubleshooting through custom expressions, top-notch security, support for the latest framework (.NET 7), stability, and multiple deployment options support (On-Premise, SaaS). 

The Lightrun dedicated package for .NET is available through the NuGet gallery. To learn more about this new runtime support and get started with it, please read this blog.

New! RBAC Support for Enhanced Enterprise-Grade Security and Governance

Lightrun enhances its enterprise-grade platform with the addition of RBAC (role based access control) support to ensure that only authorized users have access to sensitive information and resources as they troubleshoot their live applications. By using Lightrun’s RBAC solution, organizations can create a centralized system for managing user permissions and access rights, making it easier to enforce security policies and prevent security breaches.

This solution offers 3 main components: User groups, User Roles, and Agent Pools. To learn more about the benefits and settings of RBAC, read our documentation.

This feature helps improve organization’s data security and streamlines its workflows. For more information and help with setting this up, please reach out to our support team.

NEW! Lightrun Metrics for Java Runtime Support

Lightrun has also launched an upgraded version of Metrics integrated with the IntelliJ IDE plugin for Java runtime troubleshooting. The enhanced Lightrun Metrics solution is now available as a separate tab in the plugin, providing developers with a dedicated tool to address application performance-related problems. Previously, all outputs from Metrics were directed to the Lightrun console, but with the latest implementation, these outputs are sent to the newly introduced tab within the plugin.

With the enhanced implementation, the Lightrun metrics helps developers tackle the following common challenges:

1. Complexity around contributing factors to performance issues (infrastructure related issues, 3rd Party services performance, concurrency, etc.)
2. Reproducing performance issues locally is a huge challenge, with Lightrun Metrics, developers can avoid the hassle of setting up a production environment with the right data as they debug performance issues.
3. Performance issues often are specific to users or segments, hence, pinpointing them to a specific client or segment using profilers and APM tools is hard. In addition, such tools (APMs) do not provide code related information. With Lightrun Metrics, developers would find it intuitive to debug such issues directly from the IDE dedicated plugin tab.

The solution currently supports the collection of 4 different KPIs:

• Tic-Toc (Block Duration) – Measures the elapsed time for executing a specified block of code, within the same function
• Method Duration – Measures the elapsed time for executing a given method
• Custom Metric – Enables developers to design their own custom metric, using custom expressions that evaluate to a numeric result of type long. Custom metrics can be created using the configuration form in the Lightrun IDE plugin or from the CLI
• Counters (coming soon!) – Counts the number of times the code line is reached

Each of the above supported metrics is being collected and calculated on a 24 hours timeline as well as can be analyzed within a specific time range to allow developers to zoom into specific issues. In addition, developers can gain metrics visibility per single runtime agent or across multiple ones (See Lightrun Metrics for Java in action in this demo video).

To get started with Lightrun Metrics and learn more, please refer to our documentation.

NEW! LogOptimizer Support for .NET Runtime 

In addition to the previously supported runtime development languages including Java, JavaScript, and Python, Lightrun introduced its support for .NET to allow developers to optimize their overall cost of logging within their .NET applications. With the LogOptimizer solution, developers can receive a report showing the main log lines that are candidates for replacement with Dynamic Logs.

To learn more about the LogOptimizer, please read more here.

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 – Q2 2023 appeared first on Lightrun.

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

NEW! Lightrun Log Optimizer() Launched!

Lightrun’s Log Optimizer  is a new and unique log-optimization and cost- reduction solution that is part of the Lightrun IDE plugins. It allows developers to scan their source code (a single file or complete project) across the supported runtimes (Java, Python, and Node.js) for log waste, and get in seconds the log lines that are replaceable by Lightrun’s dynamic logs. 

By using this solution developers can save up to 40% of their logging costs, and reduce around 60% of logging noise volume. For more information about the Log Optimizer solution, visit our website. 

New! Actions Tab Added to Lightrun IntelliJ IDE and VSCode Plugins

With the new tab, developers can better manage their existing and new Lightrun actions (Logs and Snapshots). This feature helps developers more easily gain insights while debugging. Within the new tab, they can filter actions and select the ones they care about based on their status: Error, Active, or Expired.

NEW! Additional Java runtime support

The Lightrun JVM agent now supports JDK 18 and JDK 19.

Developer Productivity & User Experience Enhancements

Lightrun strives for developer productivity and efficiency throughout the troubleshooting workflow. With that in mind, we have implemented several capabilities and enhancements to our platform. Read more about them below.

Sharing Snapshot Hits!

With this new feature, developers can share a snapshot result with their teammates for additional review. This capability allows developers to better collaborate and get help in resolving complex issues. This should expedite fixing complex issues and reduce the overall MTTR. It helps unify troubleshooting visibility among team members.
To use this new feature within the IDE plugin, upon capturing a snapshot hit,  use the Share button and choose from among the available options: Copy link, share via Slack, share as Jira issue. 

Additional Supported Target Outputs for Logs and Metrics 

Users can now select specific integrations (logz.io for logs / Prometheus for metrics) as their action output targets. This option makes it easier to configure where to view your output in addition to the Lightrun Console. For more information, see Action Output Target.

Lightrun Log Console Enhanced for Greater User Experience

We have added filename and line number to the log output format, as well as the ability to right-click and navigate to the relevant line using the “goto” action, or copy the entire row. 

Lightrun VSCode Plugin Enhanced for Better Snapshots Consumption

• Lightrun users can now view snapshot hits created by other users in their organization. This contributes to cross team collaboration, visibility into investigations by other teammates, and a more streamlined troubleshooting process.
• Snapshot hits data now loads much faster. This shortens the time to insights and expedites the overall troubleshooting process. In addition, we’ve extended the variable tree depth to give more information in every snapshot.
• We have added the ability to search a snapshot to help you find the data you’re looking for, faster.

Enhanced User Experience: Collapse and Expand Snapshots

In the latest release, we’ve improved the user experience around snapshots by providing an  expanded variables section as seen in the below screenshot. The view below is of a Jetbrains IDE; VSCode has been similarly enhanced.

Not a Lightrun user just yet? Start using Lightrun today, or request a demo to learn more.

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

Lightrun, the leading Developer Observability Platform for production environments, announced today that it has extended its support to include C# on its plugins for JetBrains Rider, VSCode, and VSCode.dev. With this new runtime support, .NET developers can troubleshoot their apps against .NET Framework 4.6.1+, .NET Core 2.0+, and .NET 5.0+ technologies.

This new runtime support enables developers to seamlessly integrate Lightrun’s dynamic instrumentation and live debugging capabilities into their .NET applications running on these popular development platforms without requiring any code changes or redeployments.

It’s important to understand that Microsoft’s .NET technology underwent a significant evolution over the past years from being a closed development technology up until .NET 5.0 release in 2021, when it became open-source and publicly available on other operating systems like Linux.

With the above transformation and growing adoption of .NET, development teams are faced with the ongoing task of delivering code at an increasingly rapid pace without sacrificing the critical components of quality and security. This challenge is exacerbated by the intricate and elaborate nature of distributed architecture. While this architecture allows for ease of development and scalability, it also presents a unique challenge in terms of identifying and resolving issues that may arise. 

Discovering an issue within your code, whether through personal observation or client feedback, can be an unpleasant experience. The cloud environment, particularly within a distributed and serverless context, can make it challenging to understand the root cause of the problem. As multiple microservices communicate with each other, it is difficult to gain a comprehensive view of the entire application. Moreover, recreating the same situation locally is almost impossible. The situation is compounded by the dynamic nature of the environment, where instances are deployed and removed unpredictably, making it even more challenging to gain visibility into the issue at hand.

Troubleshooting .NET – Current Options

As mentioned earlier, troubleshooting .NET applications can be a very complex task for developers. Within the native IDEs, .NET developers have various options to address issues encountered during the production phase. Here are some of them:

• Crash Dumps can provide insight into why code crashes, but analyzing them requires specific skills. However, crash dumps cannot identify the root cause of the issue leading to the crash.
• Metric and Counters to collect and visualize data from remotely executing code can provide better insights into the system. However, there are limitations to dynamically adjusting the scope of focus to specific variables or methods.
• Logging is a common and straightforward technique to help developers identify issues in running code. It provides a wealth of information, but irrelevant data can be stored, particularly when logging at scale. Consolidating logs into a single service, such as Application Insights, requires accurate filtering to separate important data from the noise. Additionally, static logging does not provide flexibility in what to log or the duration of the logging session.
• Snapshot debugging allows for remote debugging of code within the IDE. When exceptions are thrown, a debug snapshot is collected and stored in Application Insights, including the stack trace. A minidump can also be obtained in Visual Studio to enhance visibility into the issue’s root cause. However, this is still a reactive solution that requires a more proactive approach to problem-solving. It also only works on specific ASP.NET applications.
• Native IDE Debuggers – built-in debuggers like the one that comes with the JetBrains Rider IDE is good for local debugging, however, it has few drawbacks. It stops the running app for breakpoints and other new telemetry collections, and cannot really help with complex recreation of production issues.

Live Debugging of .NET Applications with Lightrun!

Lightrun provides a unique solution for developers who want to improve their code’s observability without the need for code modifications during runtime. The magic ingredient is the Lightrun agent that enables dynamic logging and observability that is added to the solution in the form of a NuGet package. Once included, it is initialized in your application starting code. And that is it. From there, the Lightrun agent takes care of everything else. And by that, it means connecting to your application at any time to retrieve logs and snapshots (virtual breakpoints) on an ad-hoc basis, without the unnecessary code modification/instrumentation, going through the rigorous code changes approval process, testing and deployment. 

Getting Started with Lightrun for .NET within VSCode and Rider IDEs

As shown in the below workflow diagram, .NET developers can get started with Lightrun by following the 5 simple steps.

Detailed Step by Step Instructions: VS Code IDE

STEP 1: Onboarding and Installation

To get started with Lightrun for .NET in VS Code IDE, create a Lightrun account.

Then follow the below steps to prepare your C# application to work with Lightrun (Code sample is available in this Github repository).

Once you’ve obtained your Lightrun secret key from the Lightrun management portal (https://app.lightrun.com), please install the VS Code IDE plugin from the extensions marketplace as shown in the below screenshot.

Post the IDE plugin installation and your user authentication, you should be able to start troubleshooting your C# application directly from your IDE by running it from either your IDE, command-line, or GitHub Actions. 

STEP 3: Snapshots

From the VS Code IDE, run your C# application. Once the app is running, developers can add virtual breakpoints (called Lightrun Snapshots) without the need to stop the running app as well as add dynamic and conditional logs.The below screenshot shows how a Lightrun snapshot would look inside the VS Code plugin, and how it provides the developers with the full variable information and call stack so they can quickly understand what’s going on and resolve the issues at hand.

The above example demonstrates a Lightrun snapshot hit on the C# Fibonacci application (line 42). 

STEP 4: Conditional Snapshots 

In the same way developers can use the Lightrun plugin to add snapshots, they can also include conditions to validate specific use cases throughout the troubleshooting workflow. As seen in the below example, developers can add a conditional snapshot that only captures the fibonacci number that is divisible by 5 (line 51 in the Fibonacci code sample).

STEP 5: Logs 

Below screenshot shows how a log could be used within the VS Code IDE plugin to gather specific variable outputs that could be piped into the Lightrun IDE console or the STDout. Such troubleshooting telemetry can be also easily shared from within the plugin via Slack, Jira, or a simple URL as a way of facilitating cross-team collaboration.

Step 6: Conditional Logs

To add a condition to the troubleshooting logs output, you can use the conditional logs field within the IDE plugin as shown below. For the fibonacci code sample, we can only pipe to the Lightrun console the numbers (n) that are divisible by 5 (n % 5 == 0).

Detailed Step by Step Instructions: Rider IDE

In a similar method like with the VS Code IDE, developers can follow the steps below within the Rider IDE and troubleshoot their C# applications. 

STEP 1: Onboarding and Installation

To get started with Lightrun for .NET in Rider IDE, create a Lightrun account.

Then follow the below steps to prepare your C# application to work with Lightrun.

Once you’ve obtained your Lightrun secret key from the Lightrun management portal as noted above, please install the Rider IDE plugin from the extensions marketplace as shown in the below screenshot.

Post the IDE plugin installation and your user authentication, you should be able to start troubleshooting your C# application directly from your IDE by running it from either your IDE, command-line, or GitHub Actions. 

STEP 3: Snapshots

Within the Lightrun Rider IDE once the application is running, developers can add virtual breakpoints (called Lightrun Snapshots) without the need to stop the running app as well as add dynamic and conditional logs.The below screenshot shows how a Lightrun snapshot would look inside the VS Code plugin, and how it provides the developers with the full variable information and call stack so they can quickly understand what’s going on and resolve the issues at hand.

The above example demonstrates a Lightrun snapshot hit on the C# Fibonacci application (line 52). 

STEP 4: Conditional Snapshots 

In the same way developers can use the Lightrun plugin to add snapshots, they can also include conditions to validate specific use cases throughout the troubleshooting workflow. As seen in the below example, developers can add a conditional snapshot that only captures the fibonacci number that is divisible by 10 (line 52 in the Fibonacci code sample).

STEP 5: Logs 

Below screenshot shows how a log could be used within the VS Code IDE plugin to gather specific variable outputs that could be piped into the Lightrun IDE console or the STDout. Such troubleshooting telemetry can be also easily shared from within the plugin via Slack, Jira, or a simple URL as a way of facilitating cross-team collaboration.

The above example demonstrates a Lightrun logpoint that was added to the C# Fibonacci application (line 31) and the log output displayed in the dedicated Lightrun console. 

Step 6: Conditional Logs

To add a condition to the troubleshooting logs output, you can use the conditional logs field within the IDE plugin as shown below. For the fibonacci code sample, we can only pipe to the Lightrun console the numbers (n) that are divisible by 10 (i % 10 == 0).

Bottom Line

With Lightrun, developers can identify and resolve issues proactively, reducing downtime, and enhancing the user experience while also reducing overall costs of logging. If you’re a .NET developer looking to simplify your debugging process, give Lightrun a try and experience the difference it can make in your development workflow.

To see it live, please book a demo here!

The post Lightrun Launches New .NET Production Troubleshooting Solution: Revolutionizing Runtime Debugging appeared first on Lightrun.

Intro

Lightrun enhances its enterprise-grade platform with the addition of RBAC support to ensure that only authorized users have access to sensitive information and resources as they troubleshoot their live applications. By using Lightrun’s RBAC solution, organizations can create a centralized system for managing user permissions and access rights, making it easier to enforce security policies and prevent security breaches.

In addition, Lightrun’s RBAC new solution helps improve efficiency and reduce the administrative burden associated with managing user access rights. With the new solution, administrators can define roles and permissions for different groups of users across dedicated debugging agent pools, rather than managing access on an individual basis. This makes it easier to assign and revoke permissions as needed, without having to manually manage access for each user.

As illustrated above, with the new Lightrun’s RBAC implementation, organizations can benefit from added values to organizations that adopt it. From compliance, resource allocation, separation of duties, and risk management, the implementation of RBAC can be the determining factor between an organization that is riddled with security vulnerabilities and disorder, and one that is well-managed and secure.

Introducing Lightrun RBAC 

To ensure each team member as well as development leadership within DevOps teams have the right access and permissions to each of their applications, Lightun is launching its RBAC support. With this new enterprise security component, the entire Lightrun platform is now fully governed within the organization. 

Lightrun’s Role Based Access Controls are divided into 3 main pillars that are controlled, manageable, and configurable through the Lightrun management portal as well as the command line interface (CLI). Customers that wish to upgrade their IDE plugins and management server to the latest version with RBAC support, should contact the Lightrun account executive team to get this capability enabled. 

Once the groups, users and agent pools are in place, that’s when they can be matched through different configurations. As an example, if an administrator would like to group the agents that are used to troubleshoot the production environment and make these agents available only to a specific team (e.g. DevOps team), he would define the Production agent pool and then the DevOps user group while defining its access to the Production agent pool.

By utilizing the mentioned features, an organization has the ability to assign various roles to developers, testers, Ops, IT, and other professionals within specific Lightrun agent pools and groups, while ensuring adequate security measures and governance

As illustrated below, the group managers would create, maintain, and modify the roles and privileges of the different team members from the management server user interface. They can create new groups, add new users, modify privileges, create agent pools and more to properly manage the organization.

The users within the different groups will then get a reflection of their allocated agent pools directly from the Lightrun IDE plugin (JetBrains IDEs and VSCode) where they can troubleshoot their apps across production, staging, QA, and any other environment by simply selecting the relevant agent pool from the RBAC dropdown list in the plugin (see example below).

Bottom Line

As organizations scale and mature, there is a need for proper security and governance within their teams. Specifically in distributed workloads where developers are disconnected from their remote applications running remotely (serverless, container POD, etc.), it is imperative to provide them with the right level of control so they can perform their troubleshooting activities properly, and without any security risk to the organization. 

With the launch of Lightrun RBAC support, customers can now enjoy the following benefits:

1. Ability to restrict users access through the user groups, and permissions based on the role within the organization and user groups
2. Logically organize all of Lightrun debugging agents into pools to:
   1. Continuously and simply maintain environment debugging through a secure and centralized system
   2. Easily scale and manage the troubleshooting efforts as the team grow 
   3. Compartmentalize the agents and the troubleshooting data to limit user access and control

To learn more about Lightrun RBAC support please visit our website.

The post Lightrun Bolsters Security Measures with Role-Based Access Control (RBAC) appeared first on Lightrun.