Welcome to 2020, where Google Drive can fail for some of you but not others, you can’t access your passwords, and you can’t withdraw cash on vacation. This stranded on a desert isle dream was reality in the month of January, which saw drama in the financial services and internet infrastructure sectors. January’s downtime reinforces just how connected we have become, and how reliant we are on infrastructure that can seemingly fail on a whim.
There’s no one-size-fits-all migration path for moving legacy applications to the cloud. These applications typically reside on either physical servers, virtual machines or on premises. While the goal is generally to rearchitect or redesign an application to leverage cloud-native services, it’s not always the answer.
At the core of the LogicMonitor solution, there is the LogicMonitor Collector. The Collector is a small Java app installed on servers in your environment that collects monitored data from your various devices and then sends that data to LogicMonitor for retention and display. The Collector is what connects your environment to the cloud and allows you access from anywhere. However, sometimes these Collectors can go down, potentially leading to gaps in monitoring.
We've all worked with tightly-coupled code. If a butterfly flaps its wings in China, the unit tests break. Maintaining a system like this is...unpleasant. In this article, Jonathan Miles dives into the origins of tight-coupling. He demonstrates how you can use dependency injection (DI) to decouple code. Then he introduces a novel decoupling technique based on delegation that can be useful when DI is not an option.
One of the main benefits of using an all-in-one observability suite like Stackdriver is that it provides all of the capabilities you may need. Specifically, your metrics, traces, and logs are all in one place, and with the GA release of Monitoring in the Cloud Console, that’s more true than ever before. However, for the most part, each of these data elements are still mostly independent, and I wanted to attempt to try to unify two of them — traces and logs.
Using dashboards in Stackdriver Cloud Monitoring makes it easy to track critical metrics across time. Dashboards can, for example, provide visualizations to help debug high latency in your application or track key metrics for your applications. Creating dashboards by hand in the Monitoring UI can be a time-consuming process, which may require many iterations. Once dashboards are created, you can save time by using them in multiple Workspaces within your organization.
Serverless applications, due to their distributed nature, are often stuck having to reinvent the wheel. While small utility scripts and functions are often easily instrumented and monitored, anything of a transactional nature will need to implement special code to provide developers with common tools like stack traces, atomicity, and other patterns that rely on a singular flow of control.
