Speaker

Michael Haberman

Michael Haberman

Co-Founder & CTO at Aspecto

Tel Aviv, Israel

Michael is the Co-Founder and CTO of Aspecto, a distributed tracing platform. After serving as a software developer in an elite unit in the Israeli Intelligence branch, Michael worked with a few startups on building and scaling their microservices infrastructure.

Prior to co-founding Aspecto, he was the Chief Architect at Playbuzz. In his free time, Michael also lectures and conducts workshops on distributed services at conferences.

Here are some of my previous talks:
https://www.youtube.com/watch?v=U_sK08cyvf8,
https://www.youtube.com/watch?v=AwvcrqtA4XE,
https://www.youtube.com/watch?v=ewJdEfqXP8s,
https://youtu.be/yqHxcm0soTU,
https://youtu.be/SYe4eAzEJDU,
https://www.youtube.com/watch?v=IV2KHDxy7dQ,
https://www.youtube.com/watch?v=M7J2FvlKDGM&t,
https://www.youtube.com/watch?v=t9zANvETQDs,
https://www.youtube.com/watch?v=Q_VT3DgfqkQ,
https://www.youtube.com/watch?v=YtHkclzU3lw,
https://www.youtube.com/watch?v=CJ_ou-ITkf4&t=1s

Area of Expertise

  • Information & Communications Technology

Topics

  • OpenTelemetry
  • Observability
  • distributed tracing
  • microservices
  • Microservice Architecture
  • Node.js
  • TypeScript
  • JavaScript
  • Kubernetes
  • Angular
  • CNCF
  • distributed systems

Logging vs Tracing: Why Logs Aren’t Enough to Debug Your Microservices

When debugging microservices, it can be challenging for developers to identify the root cause of issues. Not to mention how frustrating it is to search through endless logs across multiple services and the time it takes them.

With all these challenges, however, there is a silver lining — distributed tracing. Where logging is bounded, distributed tracing thrives.

In this session, you'll learn what distributed tracing is, its benefits, what tools are out there for using tracing, and how you can use them to overcome logging challenges when dealing with distributed applications.

By the end of this session, you'll be able to use tracing to spend less time debugging microservices.

End to end visibility into event-sourcing in Node.js

In recent years the usage of event-sourcing systems like Kafka or SQS is growing rapidly among Node.js applications. Building systems around an event-driven architecture simplifies horizontal scalability in distributed computing models and makes them more resilient to failure. This is because applications state can be copied across multiple parallel snapshots for high availability. But with these advantages new challenges are arising - mainly to get visibility in these complex processes.

Since event-driven architecture is asynchronous by nature, it's hard to keep track of what happened when and what are the relations between the different components in the system. This can be extremely important when trying to debug transactions or figuring out bottlenecks in the system.

In this talk, we will present ways to achieve end-to-end and granular visibility into complex event-sourcing transactions using distributed tracing. We will use open-source tools like OpenTelemetry, Jaeger, and Zipkin to showcase a complex Node.js system using SQS and Kafka.

Building a Software Company in a Developer’s World

It used to be difficult for software companies to acquire new users. Complex implementations and long sales processes, taking months and quarters to complete. Today, it seems like software magically appears on users' desks. Users are discovering products on their own, starting to use them at lightning speed, tell their managers and team about it, and if those companies are lucky, become advocates.

While the traditional approach of offering a product, buildings relationships through a sales cycle still works, it is not the case with developers. Which means software companies have to also adapt to the new rules of the game.

In this talk, we'll explore how to build a company in a developer’s world based on our experience at Aspecto. We'll cover the role of product-led growth in your company's strategy and give actionable items you can implement right away (frictionless onboarding, five minutes to value rule, and more). We'll dive into why content is king - from documentation to blog posts, articles, and distribution - and the role of building a community. And, the one question you need to ask yourself every step along the way.

The Complete OpenTelemetry Bootcamp in 45 minutes

OpenTelemetry is an open-source project that allows us to collect and export traces, logs, and metrics (also known as the three pillars of observability). It allows us to gather data from the events that happen in our systems that ultimately help us understand our software’s performance and behavior.

In this session, you will experience a full OpenTelemetry Bootcamp* in under 45-minutes. From the very basics, including what OpenTelemetry is and how it can help you, all the way to advanced concepts such as sampling, security, the collector, and deploying in production.

This session will serve you as the roadmap for implementing OpenTelemetry and as your guide to understanding key concepts.

*Based on The OpenTelemetry Bootcamp video series https://www.aspecto.io/opentelemetry-bootcamp/

Trace-Based Testing with OpenTelemetry

Companies these days use distributed tracing for critical functions such as performance monitoring and troubleshooting, allowing DevOps, developers, and SREs to find and fix issues in production after they happen. But here is the thing, they don’t use tracing to its full potential.

There is another use case for tracing data, and that is trace-based testing. This new method allows you to improve assertion capabilities by leveraging traces data and make it accessible while setting your expectations from a test.

We will introduce you to a new open-source called Malabi - a Javascript framework based on OpenTelemetry that allows you to easily use trace data to take your assertion capabilities to the next level.

By the end of this session, you will know how to use this method to increase your tests’ reliability and possibly prevent issues early in the development cycle.

How OpenTelemetry is Taking Over The World

With the acceleration of scale and complexity in distributed architectures, the pressure to understand and identify abnormal behavior in our system is rapidly growing. We want observability in our system.

Here is where OpenTelemetry comes into play. This vendor-agnostic open-source project allows us to collect and export traces, logs, and metrics (also known as the three pillars of observability).

In this talk, you will learn what OpenTelemetry is, its current and future state, what data to collect and how to do it properly, how to use it with Jaeger and Prometheus, and how we should use it to understand our software’s performance and behavior.

This session will serve you as the roadmap for starting with OpenTelemetry and as your guide to understanding key concepts.

OpenTelemetry Sampling: The Art of Balancing Cost and Performance

Sampling is a critical tool in observability systems since it allows us to lower the cost of generating, collecting, and analyzing telemetry data in our systems. It is a form of finding the balance between costs and performance, but the road to success is paved with obstacles.

In this session, you will learn why and how to collect the most relevant and insightful data rather than the most common. We will look into how Head and Tail sampling work and explore how to configure them to collect the most crucial data to handle scale in production. We will dive into sampling overuse use cases, learn how to avoid them, and manage cost.

You will leave this session with a complete playbook on sampling, so you're ready to implement everything you've learned immediately.

Michael Haberman

Co-Founder & CTO at Aspecto

Tel Aviv, Israel