Industry executives and experts share their predictions for 2022. Read them in this 14th annual VMblog.com series exclusive.
Logging, Debugging, and Observability in 2022
By Shai Almog, Developer Advocate, Lightrun
There has been a surge of developer-enabling technologies and patterns over the last ten years. From Agile best practices, to CI/CD, to containers and microservices — developers have been given major new advantages that allow them to ship code faster than ever before.
But this accelerated pace of software development, and the highly distributed nature of today’s systems, comes with a cost. Software quality — and specifically, finding and fixing bugs in production — has become a tightrope act for teams that are shipping fast.
Logs
Logs are the first debugging tool and they won’t lose their relevance in the future. Today’s logs are nothing like the logs we saw even 10 years ago. Logs have context metadata, are deeply searchable and can be ingested in great quantities. A few years ago it was unimaginable that I would be able to search through 1000 servers for a log line that appeared a month ago with a specific string and context. Today that’s a reality that enables the scales we reach in big deployments.
Prediction 1: Logs will Become Cheaper and More Widely Used
This is a bit of a “cowardly” prediction but it’s an obvious one. This is a competitive market with many logging providers and the scales are growing. Storage prices and hardware prices are dropping so it would make sense that we’d see enterprise grade logging becoming more mainstream.
Prediction 2: Logs will Become Dynamic
Again this is cheating. It’s already happening. Tools like Lightrun and others can inject logs into a running application without modifying the code. But at the moment this is a niche feature that has some restrictions (for safety, performance etc.). I believe this will become an essential feature that will disrupt the industry.
Prediction 3: Logs will Contain More Implicit Context
Currently logging frameworks provide developers with the means of providing context but a lot of times developers don’t understand how to make use of this properly and can’t enforce common best practices for 3rd party libraries. Meta-data context means you can point at a specific line in the log and it will tell you which user, thread and entry point is related to that specific line. Again this is something that’s already partially there, but standardization and uniform cross tooling standards leave a lot to be desired.
Prediction 4: Say Goodby to Log Levels
Log levels are annoying and problematic. We came up with them decades ago, there has to be a better way. There are already tools to dynamically modify log levels in runtime. A better approach will probably evolve moving forward.
Debuggers
Today’s debuggers aren’t that different from the debuggers we used in the 90s. There are some visual improvements, but overall the basics are the same.
Prediction 1: We will See Domain Specific Debugging Tools
A good example is tools such as the IntelliJ stream debugger mentioned here. Here we have a tool designed to debug a specific API in a specific language and present it more clearly. Chrome/Firefox web developer tools are a great example too.
Prediction 2: Time Travel Time Debugging will Make a Comeback
This is an old idea that never caught on with a wider audience back in the day. A lot of things changed since then and we’re seeing some companies such as replay trying to bring this to the masses again. I think this time this will work. Developers today are already used to pretty sophisticated tools. The languages are managed and thus implementing the debugger is easier/more consistent. We also have a more mature developer relations process that helps educate the market.
Prediction 3: Production Debugging will be Commonplace
I’m pretty biased about this but this seems obvious to me. It’s 2021 and we’re still using logs to debug production? As great as logs are (and they are), we need to go deep. When I demo Lightrun to developers the response is always “can I have this”. So I’m pretty confident that this will become commonplace.
Prediction 4: Debuggers UIs will use Creative ways to Point us in the Right Direction
Newer debuggers from Apple, JetBrains and Microsoft go overboard with some amazing UI elements. One of my favorites is JetBrains, their newer IDEs present the values of the variables faded next to the previous line. This lets you visually scan the lines of code while you see the values for each variable next to the line. I think we will see creative ideas like that, especially when dealing with asynchronous calls that are a bit harder to debug/follow.
Observability
This is a field that’s growing rapidly and changing at a neck-breaking pace. So it’s harder to predict some of the trends as there’s no “long term”.
Prediction 1: We will see Clearer Division of Roles in Observability tool Segmentation
20 years ago there were no devops, no SREs, no “on-call” etc. These jobs and duties are commonplace today. Tools emerged to service these segments and provide the level of details needed at each stage.
I think additional fine grained roles will become prominent and the tools will consolidate the functionality while segmenting their marketing messaging. E.g. Elastic currently has tools for devops, developers and SREs. Each is marketed to the appropriate segment. They are separate, yet consolidated to make the sales process easier.
Prediction 2: Observability will Integrate deeper into the Development Tools
Many features are integrated as command line tools or websites. This bucks the trend of IDE consolidation. Integrating into the IDE increases retention and connects to the developer in the place where we spend most of our time. Initial implementations probably won’t be as valuable, probably just a click to open in the web UI. But once you’re inside the IDE this opens up a richness of meta-data you can use to enhance the observability experience. As a result vendors should offer more to the users.
Prediction 3: On Premise won’t go Away
This is an easy prediction to make. Even customers that have cloud based products and already use cloud prefer on-premise in some cases.
Prediction 4: IaC Debuggers and Observability tools will Rise
Infrastructure as Code is a growing field that provides very little in terms of debugging or observing that code. I’m conflicted on this prediction. Build scripts aren’t exactly debuggable
(you can but typically you don’t and it’s very niche). IaC has serious implications, an omission or mistake can be catastrophic. We need tools to give us assurance that changes in the IaC code are safe/fixable.
Final Word
I’m pretty optimistic about the future. A decade ago I tried to raise funding for an open source development tools startup and was met with a lot of resistance from investors. They literally lectured me on the low return on investment in this niche and the terrible RoI on open source.
Today we have amazing companies like Elastic with huge market caps. As a result the pendulum swung the other way and innovative startups get massive funding before revenue. I think the next few years will show many disruptive ideas in this field and I for one am looking forward to this.
##
ABOUT THE AUTHOR
Shai Almog is a longtime Java developer, co-creator of the popular Codename One mobile Java and Kotlin platform, and current developer advocate at Tel Aviv- based Lightrun.
