Imagine instead of having to work for your microservice application, your microservice application worked for you. No need to chase developers in the middle of the night, forcing them to help you get to the root of production issues. No need to rewrite code, redeploy services or restart applications. Instead, through a single interface you have full visibility and control of all the services in your production environment. You are just one click away from extracting any piece of data from all your running microservices.
Using Rookout, a company can tackle bugs and understand issues by collecting and pipelining data on-demand.
The shift to microservices and event-based programming, coupled with the rise of containers and serverless, has fascinated me over the last few years. The software world is going through a dramatic paradigm shift, creating new investment opportunities.
One of these opportunities is visibility and real-time control of cloud-native applications. As applications became increasingly distributed, event-driven and hosted on multiple cloud platforms the need for new approach was obvious.
Every cloud native developer will tell you that debugging microservices is a nightmare: Microservices are all about breaking things down to individual components. As a side effect, ops procedures and monitoring also need to be broken down per service, but this means they lose their power for the system as a whole. Each microservice can run on multiple hosts and on multiple cloud providers. Aggregating logs from all these services, hosts and cloud providers and correlating them across all the microservice requests is a cumbersome process. Even worse, each microservice is highly likely to use a different stack (technologies / languages), and you quickly realize that monitoring microservices and modern architectures is infinitely harder than it was with a monolith architecture. Companies are moving to microservices in order to gain agility, but the lack of visibility and control can end up reducing it dramatically.
Serverless applications are an extreme example of the production visibility and control challenge of microservices. With pure stateless functions floating unpredictably around a pool of hosting resources, root cause analysis becomes almost impossible. Serverless functions are fired only as a response to an event, so they are decoupled from other functions and they have a very short life cycle. Tracking down the source of an issue where neither the services involved nor any of the integration points actually exist is a huge challenge. Currently, production debugging in a serverless architecture is like a series of shots in the dark.
The common advice to cloud native developers is to carefully plan logging needs in advance. Detailed logging is important, but it comes with adverse costs:
- Businesses allocate significant resources to deploy log instrumentation frameworks that, in turn, rely on developers to add and maintain instrumentation code deep inside their applications. This strategy comes at a high cost to developer productivity, bloats the code and is prone to errors.
- No matter how much time you invest in planning in advance, in most cases the first variable data you get from the log won’t be the data that matters. It usually only leads to the next clue which requires you to write additional code, test it, get it approved and push it to production, just to discover that it still hasn’t produced the data needed to solve the problem.
- Logs, logs, logs. Quickly, gigabytes of unstructured text is generated by your servers on a daily basis, resulting in overflowed hard drives and impressive Splunk bills / ELK storage costs.
Rookout solves all these problems by letting dev teams set up ad-hoc rules inside their production code. These rules work like non-breaking breakpoints, collecting the required data WITHOUT prior instrumentation. Rookout separates the data collection from the core application by injecting collection code in runtime. Rookout’s rules can be dynamically modified at any point without requiring code changes or redeployments. The application keeps running as usual, while the data is collected and sent to any destination. Rookout currently supports Python NodeJS and JVM based languages (Java, Scala, Groovy, Clojure etc…) on AWS, Azure, Google Cloud and local servers. With Rookout, you’re just one click away from extracting any piece of data from all your running microservices.
When our team met founders Or Weis and Liran Haimovitch for the first time, we were blown away by their vision and product depth. Both of them served as researchers and low-level software engineers in some of Israel’s most prestigious cyber-units and it was abundantly clear to us that we wanted to work with them. For us, every investment is the beginning of a journey with unexpected turns and obstacles, one that we would never set out to without feeling fully confident in our partners. We feel lucky to have Or and Liran as partners in this journey.
During the DD process we realized that production debugging is just the first obvious use case for Rookout’s technology. Every customer we introduced Rookout to has suggested several different use cases and has been eager to start testing them. We soon realized that the power of Rookout’s solution goes well beyond production debugging. Consider the implications on the economics and scale of the big data market if companies had the ability to collect, on-demand, the data they really need and only the data they need.
As Rookout progresses, we will share more information about their technology and solution. Already, we can announce that just a few months after our seed investment, over a dozen software companies already use Rookout’s solution in their production environments.
We want to welcome Or and Liran and the entire Rookout team to our portfolio and to wish them good luck!