Mobile observability,
radically reimagined
bitdrift flips the decades-old mobile observability paradigm on its head: log everything, intelligently choose what to store, and instantly deploy changes to your entire fleet.
“After integrating Capture into our development process, we've seen a remarkable transformation in both our team's efficiency and the quality of our customer experiences. We've significantly slashed our bug fixing and mobile incident resolution time, allowing us to mitigate problems at a speed we never thought possible. Our apps now run smoother and the overall stability has significantly improved. This is not just a tool; it's been a game-changer for our mobile development.”
20,000,000+
Mobile Installs
90%
Mobile Developers using Monthly
500,000,000+
Daily Logs Ingested
Old vs New
Build and scale better
The way we build and deploy software has changed radically in the past decade, but most observability is still stuck in a traditional model that severely limits how developers debug and monitor their apps. New Observability is about building and scaling better apps with unlimited telemetry, instantly deployed changes, and a cost model that
doesn’t break the bank.
Cost Constraints
Traditional Observability
It’s expensive
Whether you pay for storage or per host, Old Observability costs a lot: well past 30% of most teams’ entire infrastructure bill. That’s because you pay for what you generate, instead of paying for what you actually use and get insights from.
New Observability
Doesn’t impose cost constraints
When you only pay for the actual useful data that you store and analyze – not everything you’ve collected – your observability bill isn’t something you need to stress about. New Observability means new, more aligned pricing models.
Log Volume
Traditional Observability
Forces teams to log less
Because Old Observability is so expensive, teams take great care to only log what’s necessary. Logging less means knowing less, and not having the information and context you need when an issue happens.
New Observability
Lets you log everything
Without the cost model constraints of Old Observability, you can log everything. And we mean everything, from device events to network context. If it could conceivably be useful for debugging one day, instrument it.
Device Telemetry
Traditional Observability
Assumes dumb devices
In Old Observability, servers and devices are treated like inanimate objects: they can only send exactly what telemetry you tell them to. Beyond simple filters, there’s nothing to an agent beyond just shipping logs.
New Observability
Builds intelligence into devices
In New Observability, devices are intelligently deciding how to handle telemetry in real time. Local storage, combined with a Ring Buffer, can log everything but only store what you need.
Feedback Cycles
Traditional Observability
Has slow feedback cycles
Without all of the logs they need to deeply understand an issue when it happens, Old Observability forces teams to add new telemetry after the fact. Customers need to wait for a full deployment cycle and enough time to collect new data before your team can actually fix the problem.
New Observability
Has instant feedback cycles
New Observability uses a data / control plane split, and builds intelligence into your devices at the edge. If you need to make a telemetry change, you can do it instantly and deploy immediately without waiting for release cycles or approval.
Mobile
Traditional Observability
Ignores mobile
Mobile lags behind Server when it comes to Old Observability. Mobile developers are stuck using a smashed together medley of crash reporting and device-specific logging frameworks. Many are completely in the dark, and only know about bugs when a user reports one.
New Observability
Gives mobile the focus it deserves
Mobile developers deserve (and need!) best in class observability for their fleet. New Observability gives them feature parity with what backend developers have been enjoying for years on server.
How we do it
We've made telemetry free
Most solutions start streaming data to your expensive backend observability pipelines when you install them. bitdrift’s architecture is based on the idea of selective, retroactive storage: logging everything, but only keeping what you actually need.
The core of the bitdrift SDK is an efficient, fixed resource usage log event buffer with flush rules that are configured via real-time APIs.
It has a number of out of the box integrations that automatically record the telemetry of the application, from platform specific data, ux session replay data, to network and resource utilization, as well as ways for users to feed their telemetry into the system.
This data is persisted first through in-memory buffers and then spooled locally to a highly optimized, fixed resource Ring Buffer built to enable high volume, low overhead local telemetry storage. Logging becomes “free” in most cases as the data is only uploaded when the SDK has been configured to do so. bitdrift’s SDK allows you to capture orders of magnitude more telemetry than any other solution, without paying the cost of ingesting, indexing, and storing data.
Each client has a persistent bi-directional stream connection back to our real time control plane.
It allows you to retrieve that rich buffered data on demand, but only from the clients you need, not your entire fleet. Think of this as making distributed parallel telemetry queries across millions of devices. With a sophisticated targeting engine, you can instantly find and select the exact set of data to ingest, from a single client all the way to millions of devices.
Rules can be updated server side at any time, and are compiled down to Finite State Machines that are deployed and executed on the client against the local buffer. Any data matching those rules are then uploaded through the same persistent connection. So you're paying nothing until you really need the data: Instrument everything, but only upload what you need.
Best of all, you don’t need an app release to get this data.
Every other solution out there requires an app release to update observability, but bitdrift was built to make as much as possible reconfigurable in real-time. Why wait 2-3 weeks to fix your customers’ problems? With our solution, the control plane instantly deploys targeting rules and configuration updates at the press of a button.You can turn on and off visibility and data collection in seconds, to millions of clients. It's like a mobile development superpower, this big dial you can turn on demand.
Finally, bitdrift takes all these rich sources of telemetry and displays them in a clean, easy to parse user interface designed to speed up debugging and incident resolution.
We integrate many disparate sources of data, from low level networking calls to privacy aware session replay visualizations (and everything in between!) to provide all the context needed.
Combine all these, and you have a powerful platform that gives you a real time view into your customers’ actual experiences, finding issues in minutes instead of months.
It frees your engineers from thinking about what to log, and lets them focus on building more and fixing faster. It’s a huge change from the old observability, where you’re paying a huge amount of money for data that never gets looked at.
Features
Supercharge mobile development
Capture by bitdrift comes with a huge amount of built in functionality, right out of the box. Developers can start fixing customer problems immediately, with the best set of mobile development tools on the market. It's like getting 20 developers for free.
Session Timeline
Rich, at a glance view of a customer's entire session, with custom visualizations
UX debug with Session Replay
Bandwidth and privacy conscious session capture, allowing replay of sessions correlated with telemetry
Real-time control plane
Persistent connectivity between every client and bitdrift allows new configs to be sent and applied within seconds
Free local logging
Highly optimized, low overhead local storage effectively provides free and unlimited telemetry on the client
Resource Utilization
Detailed memory, CPU, and battery views, synchronized with a session's timeline
Native Events
Powerful set of built-in out of the box events on iOS and Android the moment the SDK is integrated. Minimal setup needed
Custom Events
Powerful matching and transforms for existing logs. No code needed
Synthetic Metrics
Build cheap metrics off of existing logging, without mobile deploys, and see them in real-time
Performance overhead
Tiny, low overhead SDK with predictable performance
Proven at scale
Deployed to 150 million+ mobile clients, billions of log lines ingested weekly
Integrations
API allows integration with existing crash management solutions as well as the federation of customer data, server or mobile
bdtailNew
Live attach to a set of clients and view telemetry in real-time. A superpower for live support and rapid development
FunnelsNew
Build a funnel on the fly with any existing log or signal in your application, and deploy it to millions of devices in seconds
Instant InsightsNew
Fleet wide views of your users and their devices
Enterprise Ready
Safeguard credentials, content, and storage
BYOB
Keep strict control over your sensitive data on your own blob storage while bitdrift runs the rest of the system as a full SaaS.
Read About BYOBSOC 2
bitdrift has partnered with Assurance Lab to achieve the SOC 2 type I compliance certification. Customers can now rest easy that their telemetry data is in good hands and governed by audited industry best practices.
Read About SOC 2Ready to get started?
Get a demo.