At Hyperlint, we've made it our mission to help developer teams take the toil out of developer content.
We do that by providing an AI-powered GitHub bot and related utilities that review technical documentation for accuracy and SEO optimization. We do everything from catching typos to automatically updating documentation based on upstream API or CLI changes.
We deeply integrate with our user's workflows and want to provide a seamless experience. It's imperative for us to know exactly what's going on behind the scenes to deliver an exceptional experience.
In this post, we'll dive into why we chose Pydantic Logfire as our observability provider.
Our need for powerful observability
Hyperlint's AI documentation review runs checks on thousands of pull requests to ensure our users' documentation is top-notch and up-to-date.
With so many developers and technical writers relying on us to review every PR, every time, we needed a monitoring solution that could keep up with our demanding workload and alert us to any issues quickly.
Enter Pydantic Logfire: simple, straightforward, and performant
After evaluating various options, we chose Pydantic Logfire for its simplicity, performance, and powerful features. Here's why Logfire stood out, in a nutshell:
Let's review each of these in detail.
Effortless integration
Pydantic Logfire seamlessly integrates with our existing logging tools. We run a lot of Python and we already heavily leverage Pydantic.
We use Loguru as our logging tool of choice and Logfire's out of the box integration made flipping it on across our app trivial. This meant we saw logs in logfire in seconds since we started with the integration.
We also leverage other integrations with our database (like Postgres, MongoDB etc.), web servers (like Flask and FastAPI), and AI partner like OpenAI and Anthropic.
The ability to integrate with our existing logging tool and log structured objects with Pydantic gave us so much value, right off the bat.
We now log spans using the instrument function along with other associated metadata, to ensure we have the right context in our observability pipeline.
@logfire.instrument("Execute review")
async def review(arg1:str, arg2:int):
...
We were up in running in no time and getting value the same day.
Debugging made easy
Logfire's intuitive interface and comprehensive logging capabilities have significantly simplified our debugging process.
When events occur in the system, we use the Logfire UI to quickly determine issues or performance bottlenecks. We can understand performance at various levels of our system.
Using Logfire helped us drop our time to review by 80%+ from initial versions because it helped us identify critical bottlenecks and performance issues with almost no effort.
On top of that, Logfire's alerts integrate with Slack, making it easy for us to see issues in real time.
Exception tracing made magical
In particular, the exception tracing experience is magical in the UI.
Logfire highlights issues and exceptions allowing us to quickly trace problematic code paths as they come up. We can even trace across services.
For example, in the below trace, we encountered an error during search indexing and were able to quickly root cause the issue so that it prevented any customer issues.
This experiences cuts out debugging time and allows us to focus on our users.
Great support for AI
Logfire's native integration with OpenAI and Anthropic means that understanding what's happening not just with respect to the metrics and logs of our application, but also the AI-related evaluations that we perform keeps our system simple and covers all of our needs.
Astonishingly responsive team
We started using Logfire very early on in their preview. We've been astonished by the responsiveness of the team, always eager to help debug issues or provide recommendations. Culturally at Hyperlint, we're focused on our end users and making them successful.
We love to see that in our partners and Logfire demonstrated that time and time again.
Deep dive: the power of context for AI apps
While Logfire's AI support might seem like a small feature, for us it's a standout feature.
Pydantic Logfire helps us maintain context throughout our observability pipeline - AI or not. When dealing with complex documentation review processes and AI-driven analyses, context is essential and Logfire provides that all in a single platform.
Pydantic Logfire allows us to:
- Trace the entire lifecycle of a documentation review or change, from initial PR creation, any AI that we perform, and ultimately to final approval.
- Identify patterns and trends across multiple PRs and repositories.
- Get alerts about problematic areas or inconsistencies.
This holistic view has been invaluable in improving our service and providing more accurate, helpful reviews to our users.
Using Logfire has re-affirmed our beliefs in how to build impactful AI apps and systems:
- Good AI monitoring is just good monitoring - since we are a small team, we are focused on high leverage tools that can do multiple things. Logfire allows us to focus on our users, not on our infrastructure.
- Compound AI Systems are the way forward - AI is just a small part of what we do to help our users. We have manual checks, third party tools, and various AI providers. We believe that systems that compose different tools together are key to building great AI apps and Logfire helps us do.
- Seamless monitoring w/ easy data access - We can visual OpenAI chats in the UI, but we can also export them using their Query Endpoint to analyze logs alongside production data.
It's critical when using AI to look at your data, and Logfire couldn't make that easier.
Logfire is a game-changer for Hyperlint
Choosing Logfire as our observability provider has been a game-changer for Hyperlint. Its simplicity, performance, and powerful features have allowed us to:
- Maintain high reliability and performance for Hyperlint's AI documentation reviewer.
- Quickly identify and resolve issues, minimizing downtime.
- Develop custom evaluation tools that integrate seamlessly with our existing workflows.
- Gain deeper insights into the AI-driven documentation processes for our customers.
Pydantic Logfire has proven to be that solution for us at Hyperlint, enabling us to focus on what we do best – helping teams create and maintain high-quality technical documentation. We've been users from the beginning are happy paying customers.
Give Logfire a try today - we love it and we're sure you will too!
