LogDNA sponsored this post.
In today’s modern application development world, speed is essential. As organizations try to find competitive advantages, one thing has become abundantly clear: faster time to market is critical. But how do you balance speed to market with safety and ensure that what you end up releasing actually works? Two of the biggest obstacles when it comes to accelerating development are the risk of breaking changes and a lack of visibility early in the development cycle.
Developers have an opportunity to innovate faster by combining modern development approaches — like feature flags — with logging for visibility.
Feature flagging gives developers the ability to release small, incremental changes to subsets of their environment so that they can test and get feedback with actual data across actual users. Essentially any atomic commit can be released with a feature flag. You can even control releases down to lines of code! This allows developers to iterate quickly, validating that changes work and are successful before releasing the change across the rest of their environments. In case a release introduces issues or users are not happy with the changes, they can be rolled back swiftly with a negligible impact.
“Historically, deployments were looked at as a risk mitigation exercise,” says Ricardo Lupo, Head of Solution Architecture at LogDNA. “Every time there was a deployment, we almost expected something to break. There were more validation steps added to try and prevent issues. The idea was to try to mitigate the potential problems of these deployments, but in reality we just added more time to the process without any real safety. As a result, developer teams added more and more features into releases. We were left with releases taking most of a weekend and requiring all-hands on deck. Because these deployments incorporated so many changes, it was really hard to pinpoint where something broke, increasing the probability that you’d roll back the entire change. Ultimately, it was your customer that suffered, as they could not benefit from the additional features that should have been deployed.”.
With feature flagging, developers can now control when and who gets to see new capabilities. New features get released, or toggled on, independently of one another, to any portion of production and in a dynamic fashion — that does not require a deployment to production to release a feature. This effectively eliminates the need for longer milestone deployments and enables changes to be atomic. Additionally, developers can test that their releases work, with real data and under production load. More importantly, developers can test whether the capabilities are the ones that their customers want and need, by choosing specific users that fit use cases to test the feature in production. The control afforded by feature flags helps to minimize the risk of issues or outages. Overall, the ability to simplify and control the release process — thereby reducing risk — while reducing load on operations teams, is one of the largest benefits of feature flagging.
The other critical component in the modern developer’s arsenal is logging. Getting insights into an application, as well as the underlying infrastructure’s behavior, early in the process is critical to the success of changes that are being made. Logs are the atomic unit of value for everything that you do from an operations perspective. Logs also represent a common interface for developers and operations to collaborate on, to help troubleshoot and resolve issues. Therefore, it is natural to want to have easy-to-use feature flags and a strong logging implementation paired together when working with a production environment.
Modern technologies present new challenges as well. Legacy three-tier architectures were relatively simple to manage, because deployments happened to discrete servers and VMs. The popularity of modern technologies, such as Kubernetes and containers, fundamentally changes how infrastructure is managed and — more importantly — how applications are deployed. Applications are abstracted away from the infrastructure they run on. Additionally, deployments and releases span multiple platform types and require orchestration and automation for rollouts and rollbacks. The amount of logs generated across these modern technologies means that teams need a simple way to consume and take action on these logs.
“Developers want an easy to consume interface that doesn’t introduce latency into their development processes,” adds Ricardo Lupo. “They want to be able to get insights early on in the development process, so they can make decisions about what they need to do next.”
LogDNA’s ability to parse and index logs upon ingestion, coupled with its natural-language search syntax, makes it easy for developers to get a value very quickly.
Integrating logging with feature flagging adds additional capabilities to give developers even faster insights into the changes they are making, and ensures operations teams have the ability to get a deep insight into their systems.
“Having an integration with LogDNA allows us to have more visibility into things that are happening within LaunchDarkly,” explains Rich Manalang, Principal Developer Advocate at LaunchDarkly. “DevOps teams can see when a feature is toggled or when someone is targeted for a particular feature.”
All of this provides the modern developer a comprehensive platform to ensure that they can release quickly and safely, with insights into what is happening with their releases every step of the way.
Learn more about LaunchDarkly’s integration with LogDNA here.
Feature image via Pixabay.