Nutrisense finds balance with Better Stack

Company: Nutrisense

Nutrisense is redefining how people approach their health by turning personal data into powerful, actionable insights. Whether understanding how the body responds to food, improving energy levels, or building better habits is the goal, the dots are connected through Nutrisense – all in one place.

At the core of Nutrisense is a simple idea: everyone's health journey is different, and there’s no one-size-fits-all approach. Combining continuous glucose monitoring (CGM) technology with expert support, Nutrisense empowers thousands of members across the country to take control of their wellness.

With a focus on personalization, education, and community, Nutrisense makes health feel less like guesswork and more like a journey – one backed by data and guided by experts.

Industry: Health & wellness / Digital health tracking

Use case: Unified logging across app stack

Savings: Huge drop in logging expenses

Switched from: Datadog

The price of poor observability

The team had to manage data flowing in from over 10 external APIs, all powering a mobile app that delivers real-time, personalized insights. This meant one thing: reliable logging and monitoring weren’t optional – they were essential.

But things got tricky. Nutrisense’s backend, built with Ruby on Rails, Heroku, and Sidekiq, relied heavily on GraphQL. Since all GraphQL requests hit a single endpoint (/graphql), standard Rails logging lacked the detail needed for meaningful debugging or tracing. The team found themselves flying blind just when they needed the most visibility.

On top of that, their existing monitoring solution Datadog was becoming unsustainably expensive. In an effort to cut costs, they were forced to reduce log retention and drop important logs altogether, making investigations harder and alerting less reliable. It was clear: something had to change.

A smarter way to see everything

To get their logging under control, the Nutrisense team decided to take a more custom approach. The first step? Building their own logger – one that could actually capture the context they needed. That meant tagging every log with helpful details like the GraphQL operation name, the authenticated user, and the request ID. They used ActiveSupport::CurrentAttributes to manage this context and made sure it flowed cleanly through each incoming request.

They also pulled in lograge to clean up the noise in their logs and make the output structured and JSON-formatted, something they knew would pay off down the line when it came time to search and filter.

Once the custom logger was up and running, they swapped out the default Rails and Sidekiq loggers for their new setup. With that in place, logs were enriched, easier to read, and finally felt useful again.

From there, the team integrated Better Stack. On Heroku, that process was refreshingly simple – just adding a new log drain. Immediately, logs started flowing into Better Stack with all the context intact.

Now with proper JSON logs in Better Stack, they could slice and dice by operation_name, request_id, or user_id – key details that made investigating bugs far more efficient.

And it didn’t stop there. They enabled dyno runtime metrics for even more visibility into app performance and started using Better Stack dashboards to track key health signals. For GraphQL-specific needs, the team built custom charts that pulled in the duration of different operations and grouped them by name. When they wanted more flexibility, they switched to SQL mode and tailored the charts to exactly what they needed, like monitoring the top 5 slowest operations.

Finally, they set up alerts. Whether it’s a spike in latency or something behaving out of the ordinary, the right people on the team now get notified instantly via call, text, email, or push.

Observability solved with Better Stack

Since then, the team has migrated its stack partially to App Engine and GoodJob, but the challenges of visibility remained front and center. With Better Stack fully integrated, Nutrisense now has:

• Rich, context-aware logs for every GraphQL request.
• Custom dashboards that surface real-time performance and usage trends.
• Alerts that actually matter – sent when something’s off, not just noisy.
• A scalable, cost-effective monitoring setup that no longer forces trade-offs.

It took a little effort to get things dialed in, but now that we’re fully onboarded, Better Stack gives us exactly what we need – without the painful price tag.

— Team Nutrisense

Got an article suggestion? Let us know

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.