{"id":76399,"date":"2019-04-04T13:17:33","date_gmt":"2019-04-04T20:17:33","guid":{"rendered":""},"modified":"2025-06-27T09:25:37","modified_gmt":"2025-06-27T16:25:37","slug":"honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview","status":"publish","type":"post","link":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/","title":{"rendered":"How Honeycomb is empowering all developers to better understand their systems"},"content":{"rendered":"\n

Honeycomb is a tool for introspecting and interrogating your production systems. It\u2019s a new type of tool, designed to infuse observability<\/a> across platforms, microservices, serverless apps, and increasingly complex systems, as well as all the way down to individual customers.<\/p>\n\n\n\n

I had a chance to catch up with Emily Nakashima, our Director of Engineering at Honeycomb, to discuss the concept of observability in practice, and dive into how new tools are helping developers troubleshoot the innerworkings of complex systems and take ownership over the entire lifecycle of their code.<\/p>\n\n\n\n

Tell us about yourself and your role at Honeycomb.<\/h3>\n\n\n
\"Emily<\/figure>\n\n\n\n

I used to identify as the frontend engineer most likely to be added to the on-call rotation, which probably gives you some sense for how weird my technical path has been. I currently manage the engineering and design teams at Honeycomb, and in the recent past I’ve mostly worked on other SaaS developer tools, including Bugsnag and Github. I can find joy working on most types of products, but I am fascinated by the all the intricacies involved in shipping good software, so designing and building the technology that helps my peers do that every day is peak nerdy delight for me.<\/p>\n\n\n\n

My interests as an engineer skew toward frontend technologies, monitoring, observability, and performance optimization, but I started my journey in the early 2000s \u2014 where everyone was a \u201cwebmaster\u201d or a \u201cweb designer\u201d and I was both \u2014 and I began with html skills and a design degree rather than a traditional CS degree program, so I also have a lot of enthusiasm for user experience design and related disciplines too.<\/p>\n\n\n\n

How has the emergence of microservices and serverless complicated observability?<\/h3>\n\n\n\n

The rise of microservices and serverless are both helping us ship new software quickly, iterate fast, and control costs. They’ve also helped us build dramatically more complex systems with many new and poorly-understood failure modes, and they have made a lot of our traditional monitoring tools less effective. In particular, host-level system metrics and alerts on those metrics have become a whole lot less valuable. Charity Majors, Honeycomb’s cofounder and CEO, has spoken<\/a> about this often and more eloquently than I will, but I’ve felt this pain over and over with my own systems while serving heterogeneous customer traffic.<\/p>\n\n\n\n

There’s always the moment where one small customer contacts you about some problem they are having with your system, and there’s no way to dig down to that one tiny slice of traffic with your metrics. In the old monolith world, maybe<\/em> you could save yourself by digging through the logs for a single service, but it’s a lot tougher to do that when the request might have been routed through a dozen distinct services and you don’t know where the issue is happening. This is the exact problem that sets the stage for needing observability instead of just metrics \u2014 suddenly you need to be able to ask questions about just this one user, just this one request, or just this one path through your infrastructure.<\/p>\n\n\n\n

How is Honeycomb supporting some of the new responsibilities developers have?<\/h3>\n\n\n\n

Honeycomb is built by and for teams that write, deploy, operate, and maintain their code from end-to-end, from planning to production. We know not every team is here yet \u2014 there are still plenty of teams that throw their software over a wall to someone else to deploy or manage in production. The thing that brings Honeycomb engineers together is this common belief that the best software comes out of a model of software ownership \u2014 where the same team writes the code and<\/em> deploys it to production and <\/em>monitors its failure or success there once it’s deployed. Once you start doing that, it’s really valuable to have tools that let you dig into what your code is doing in production from the perspective of the code itself.<\/p>\n\n\n\n

The prior generation’s tools \u2014 particularly metrics platforms and APM tools \u2014 are best equipped to answer \u201chow is my infrastructure <\/em>doing?\u201d and \u201chow is this application doing on this one set of hosts?\u201d<\/em> However, we’ve learned that the question we really want to answer most of the time is, \u201chow are individual customer requests doing as they traverse the entire path from the customer’s device to our systems and back?\u201d<\/p>\n\n\n\n

As an engineer, when it’s suddenly your job to figure out why a particular canary deploy is throwing errors or why just one customer in Latvia can’t log in, it’s a massive time saver to have tools that let you drill down to the individual request and are aware of when you last deployed and what changed in that deploy.<\/p>\n\n\n\n

In the early 2010s, I remember having the sad experience of constantly sending customer bug reports back to the support team with a message like, \u201cCan’t reproduce. Let us know if the customer can provide reproduction steps.\u201d With high cardinality querying over wide events, our software engineers can now identify what went wrong and fix it before the customer even has time to finish emailing us about it. It feels amazing.<\/p>\n\n\n\n

There are definitely teams that may resist this trend toward software ownership. Some folks \u201cjust want to write code,\u201d or they are rightly intimidated by all the new skills they might have to learn. I hope that the learning aspect is something we can make easier, which should help more teams start to adopt it in a bottom-up way, but I also expect that over time, companies will see the increase in software quality and decrease in time to incident resolution that can come out of software ownership and will start a top-down push too.<\/p>\n\n\n\n

How does Honeycomb instrument observability?<\/h3>\n\n\n\n

On nearly every engineering team I know, instrumentation work has been a careful handicraft performed by only the most senior, forward-thinking engineers. This tends to work against the goal of achieving observability, where you really want all systems and all new features to have some basic level of instrumentation.<\/p>\n\n\n\n

At Honeycomb, we knew we needed to help make instrumentation best practices more accessible to engineers to make them successful with the product<\/a>. We definitely have a lot of blog posts and documentation on the topic \u2014 the basic advice is always, start at the edge and try to capture as much metadata as possible (\u201cwide events\u201d) at each important point in the request lifecycle. We encourage people to start with at least one event per HTTP request to your systems and build from there, although in a tracing universe, you often end up with many, many events (\u201cspans\u201d) per request.<\/p>\n\n\n\n

The blog posts<\/a> and documentation<\/a> help, but most engineering teams are busy enough that it can be tough to take time to read all this educational content and then<\/em> spend the time hand-instrumenting your apps. Beelines<\/a> are our attempt to roll up a lot of those best practices into an easy-to-use open source library that will automatically instrument apps using the most common languages, patterns, and libraries.<\/p>\n\n\n\n

The thing I like about them is that they are both automatic and  extensible \u2014 so you get events and traces automatically out of the box, but it’s easy to add your own custom spans and context to them as you find there is more information you want to collect about your software. The early Honeycomb team was a lot of engineers with many gripes about the inability to do custom instrumentation in APM-style tools, so we tried to capture all that good APM-style data and leave room for customization too.<\/p>\n\n\n\n

What are the most common or interesting use cases today?<\/h3>\n\n\n\n

I’m a bit biased because I came from a frontend engineering background, but my favorite observability use cases today are ones that span all the way from the client \u2014 usually running on a customer’s device, like a laptop or mobile phone \u2014 to the server. Charity always says, \u201cNines don’t matter if users aren’t happy,\u201d meaning that an arbitrary statistic like having 99.999% uptime doesn’t matter if your users can’t successfully use your product.<\/p>\n\n\n\n

But how do you know if users are<\/em> happy? We started to try to answer that question by instrumenting our web application, but a web app running in the cloud somewhere is still many hops away from our end users. And new client-side web technologies like Service Worker suddenly mean that significant user interactions with your app may not trigger an HTTP request to your infrastructure at all.<\/p>\n\n\n\n

We are playing with the idea of using tracing-style instrumentation to capture user sessions from the client perspective, so we can catch issues even earlier in the process \u2013 for example, noticing when requests fail or javascript does something unexpected in the browser. And<\/em>, catch those weird cases like, \u201cThis customer got three steps into a complex configuration flow and gave up.\u201d I like it because it brings together bits of product analytics, user research, and debugging in production to help build up a more holistic picture of user happiness.<\/p>\n\n\n\n

What innovations on the product roadmap are you most excited about?<\/h3>\n\n\n\n

Honeycomb started as an event-driven product that mainly displayed time series data, but we realized that that event-based data model supported lots of other amazing visualizations quickly and easily \u2014 including tracing! In 2018 we launched a tracing product<\/a> and I am so, so excited about using 2019 to better understand how the power of events and traces can be combined.<\/p>\n\n\n\n

Tracing products tend to be very depth-first in the way they make you look at systems, and classic event-driven Honeycomb does great with breadth-first inquiries. We are working on building Honeycomb into a tool that lets you seamlessly move back and forth between those broad and deep views, something that can be tricky in other products when you are jumping among logs, metrics, and traces all living in different tools.<\/p>\n\n\n\n

Talk a bit about the Honeycomb community. How does Honeycomb support a thriving community?<\/h3>\n\n\n\n

There are two ways we are enormously lucky here \u2014 we have a great community of diehard Honeycomb customers who have evangelized us to their teams and their peers, and we have a number of early engineers on the team who love to teach and help others be successful with Honeycomb.<\/p>\n\n\n\n

In particular, the Honeycomb Slack workspace has been a great place to get customer feedback and share conversations around best practices \u2014 and we often find that Honeycomb engineers do as much learning as they do teaching. I think Honeycomb’s emphasis on transparency has helped so much with community building \u2014 we are open about saying what we don’t know and what problems we haven’t solved yet, and I think we end up with a much better conversation with customers and leaders in the observability space as a result.<\/p>\n\n\n\n

Follow Emily @eanakashima<\/a> and Honeycomb @honeycombio<\/a>.<\/p>\n\n\n\n

More questions for Emily? Let us know in the comments below.<\/p>\n","protected":false},"excerpt":{"rendered":"

Honeycomb is a tool for introspecting and interrogating your production systems. It\u2019s a new type of tool, designed to infuse observability across platforms, microservices, serverless apps, and increasingly complex systems, as well as all the way down to individual customers.<\/p>\n","protected":false},"author":5562,"featured_media":76429,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"msxcm_post_with_no_image":false,"ep_exclude_from_search":false,"_classifai_error":"","_classifai_text_to_speech_error":"","footnotes":""},"post_tag":[2271],"content-type":[346],"topic":[2240,2241],"programming-languages":[],"coauthors":[556],"class_list":["post-76399","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","tag-community-partners","content-type-news","topic-application-development","topic-cloud","review-flag-alway-1593580310-39","review-flag-new-1593580248-669"],"yoast_head":"\nHow Honeycomb is empowering all developers to better understand their systems | Microsoft Open Source Blog<\/title>\n<meta name=\"description\" content=\"Emily Nakashima, Director of Engineering at Honeycomb, discusses the concept of observability in practice, and dive into how new tools are helping developers troubleshoot the innerworkings of complex systems.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How Honeycomb is empowering all developers to better understand their systems | Microsoft Open Source Blog\" \/>\n<meta property=\"og:description\" content=\"Emily Nakashima, Director of Engineering at Honeycomb, discusses the concept of observability in practice, and dive into how new tools are helping developers troubleshoot the innerworkings of complex systems.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/\" \/>\n<meta property=\"og:site_name\" content=\"Microsoft Open Source Blog\" \/>\n<meta property=\"article:published_time\" content=\"2019-04-04T20:17:33+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-06-27T16:25:37+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/04\/honeycomb-logo-720x240.png\" \/>\n\t<meta property=\"og:image:width\" content=\"719\" \/>\n\t<meta property=\"og:image:height\" content=\"240\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Rachel Perkins\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/04\/Emily-presenting_TW-560x1000.png\" \/>\n<meta name=\"twitter:creator\" content=\"@OpenAtMicrosoft\" \/>\n<meta name=\"twitter:site\" content=\"@OpenAtMicrosoft\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Rachel Perkins\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 min read\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/\"},\"author\":[{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/author\\\/rachel-perkins\\\/\",\"@type\":\"Person\",\"@name\":\"Rachel Perkins\"}],\"headline\":\"How Honeycomb is empowering all developers to better understand their systems\",\"datePublished\":\"2019-04-04T20:17:33+00:00\",\"dateModified\":\"2025-06-27T16:25:37+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/\"},\"wordCount\":1833,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/04\\\/honeycomb-logo-720x240.png\",\"keywords\":[\"Community\\\/partners\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/\",\"url\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/\",\"name\":\"How Honeycomb is empowering all developers to better understand their systems | Microsoft Open Source Blog\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/04\\\/honeycomb-logo-720x240.png\",\"datePublished\":\"2019-04-04T20:17:33+00:00\",\"dateModified\":\"2025-06-27T16:25:37+00:00\",\"description\":\"Emily Nakashima, Director of Engineering at Honeycomb, discusses the concept of observability in practice, and dive into how new tools are helping developers troubleshoot the innerworkings of complex systems.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/#primaryimage\",\"url\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/04\\\/honeycomb-logo-720x240.png\",\"contentUrl\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/04\\\/honeycomb-logo-720x240.png\",\"width\":719,\"height\":240,\"caption\":\"a close up of a logo\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/2019\\\/04\\\/04\\\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"How Honeycomb is empowering all developers to better understand their systems\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/\",\"name\":\"Microsoft Open Source Blog\",\"description\":\"Open dialogue about openness at Microsoft \u2013 open source, standards, interoperability\",\"publisher\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/#organization\",\"name\":\"Microsoft Open Source Blog\",\"url\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/08\\\/Microsoft-Logo.png\",\"contentUrl\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/08\\\/Microsoft-Logo.png\",\"width\":259,\"height\":194,\"caption\":\"Microsoft Open Source Blog\"},\"image\":{\"@id\":\"https:\\\/\\\/opensource.microsoft.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/x.com\\\/OpenAtMicrosoft\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How Honeycomb is empowering all developers to better understand their systems | Microsoft Open Source Blog","description":"Emily Nakashima, Director of Engineering at Honeycomb, discusses the concept of observability in practice, and dive into how new tools are helping developers troubleshoot the innerworkings of complex systems.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/","og_locale":"en_US","og_type":"article","og_title":"How Honeycomb is empowering all developers to better understand their systems | Microsoft Open Source Blog","og_description":"Emily Nakashima, Director of Engineering at Honeycomb, discusses the concept of observability in practice, and dive into how new tools are helping developers troubleshoot the innerworkings of complex systems.","og_url":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/","og_site_name":"Microsoft Open Source Blog","article_published_time":"2019-04-04T20:17:33+00:00","article_modified_time":"2025-06-27T16:25:37+00:00","og_image":[{"width":719,"height":240,"url":"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/04\/honeycomb-logo-720x240.png","type":"image\/png"}],"author":"Rachel Perkins","twitter_card":"summary_large_image","twitter_image":"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/04\/Emily-presenting_TW-560x1000.png","twitter_creator":"@OpenAtMicrosoft","twitter_site":"@OpenAtMicrosoft","twitter_misc":{"Written by":"Rachel Perkins","Est. reading time":"7 min read"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/#article","isPartOf":{"@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/"},"author":[{"@id":"https:\/\/opensource.microsoft.com\/blog\/author\/rachel-perkins\/","@type":"Person","@name":"Rachel Perkins"}],"headline":"How Honeycomb is empowering all developers to better understand their systems","datePublished":"2019-04-04T20:17:33+00:00","dateModified":"2025-06-27T16:25:37+00:00","mainEntityOfPage":{"@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/"},"wordCount":1833,"commentCount":0,"publisher":{"@id":"https:\/\/opensource.microsoft.com\/blog\/#organization"},"image":{"@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/#primaryimage"},"thumbnailUrl":"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/04\/honeycomb-logo-720x240.png","keywords":["Community\/partners"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/","url":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/","name":"How Honeycomb is empowering all developers to better understand their systems | Microsoft Open Source Blog","isPartOf":{"@id":"https:\/\/opensource.microsoft.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/#primaryimage"},"image":{"@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/#primaryimage"},"thumbnailUrl":"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/04\/honeycomb-logo-720x240.png","datePublished":"2019-04-04T20:17:33+00:00","dateModified":"2025-06-27T16:25:37+00:00","description":"Emily Nakashima, Director of Engineering at Honeycomb, discusses the concept of observability in practice, and dive into how new tools are helping developers troubleshoot the innerworkings of complex systems.","breadcrumb":{"@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/#primaryimage","url":"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/04\/honeycomb-logo-720x240.png","contentUrl":"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/04\/honeycomb-logo-720x240.png","width":719,"height":240,"caption":"a close up of a logo"},{"@type":"BreadcrumbList","@id":"https:\/\/opensource.microsoft.com\/blog\/2019\/04\/04\/honeycomb-observability-helping-developers-better-understand-systems-emily-nakashima-interview\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/opensource.microsoft.com\/blog\/"},{"@type":"ListItem","position":2,"name":"How Honeycomb is empowering all developers to better understand their systems"}]},{"@type":"WebSite","@id":"https:\/\/opensource.microsoft.com\/blog\/#website","url":"https:\/\/opensource.microsoft.com\/blog\/","name":"Microsoft Open Source Blog","description":"Open dialogue about openness at Microsoft \u2013 open source, standards, interoperability","publisher":{"@id":"https:\/\/opensource.microsoft.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/opensource.microsoft.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/opensource.microsoft.com\/blog\/#organization","name":"Microsoft Open Source Blog","url":"https:\/\/opensource.microsoft.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/opensource.microsoft.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/08\/Microsoft-Logo.png","contentUrl":"https:\/\/opensource.microsoft.com\/blog\/wp-content\/uploads\/2019\/08\/Microsoft-Logo.png","width":259,"height":194,"caption":"Microsoft Open Source Blog"},"image":{"@id":"https:\/\/opensource.microsoft.com\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/x.com\/OpenAtMicrosoft"]}]}},"msxcm_animated_featured_image":null,"bloginabox_display_generated_audio":false,"distributor_meta":false,"distributor_terms":false,"distributor_media":false,"distributor_original_site_name":"Microsoft Open Source Blog","distributor_original_site_url":"https:\/\/opensource.microsoft.com\/blog","push-errors":false,"_links":{"self":[{"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/posts\/76399","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/users\/5562"}],"replies":[{"embeddable":true,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/comments?post=76399"}],"version-history":[{"count":2,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/posts\/76399\/revisions"}],"predecessor-version":[{"id":97781,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/posts\/76399\/revisions\/97781"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/media\/76429"}],"wp:attachment":[{"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/media?parent=76399"}],"wp:term":[{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/post_tag?post=76399"},{"taxonomy":"content-type","embeddable":true,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/content-type?post=76399"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/topic?post=76399"},{"taxonomy":"programming-languages","embeddable":true,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/programming-languages?post=76399"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/opensource.microsoft.com\/blog\/wp-json\/wp\/v2\/coauthors?post=76399"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}