A Comparative Guide for Moesif OpenTelemetry and Native Integrations
This guide comparatively discusses Moesif OpenTelemetry integration and native integrations to help you choose the best one for your use case.
Overview
Moesif OpenTelemetry integration allows you to send trace data of your application to Moesif. The OpenTelemetry integration lacks many of the features you get from a native integration like Node.js or Python Django. However, the OpenTelemetry integration can greatly enhance the observability of your system by complimenting the rest of the observability and monitoring features Moesif provides. The OpenTelemetry integration has been designed to leverage your product’s existing distributed tracing to analyze API performance and user behavior across services and applications.
Overview of Moesif OpenTelemetry Integration
The integration works by configuring your OpenTelemetry Exporter to send trace data to Moesif using the OTLP/HTTP protocol. To use this integration, you must make sure either of the following:
- You have instrumented your application with OpenTelemetry SDKs.
- You have configured your application to send telemetry data to an OpenTelemetry Collector that can export using OTLP over HTTP.
Moesif supports OpenTelemetry traces. It doesn’t support logs and metrics. Within traces, Moesif supports HTTP Spans, capturing HTTP request span data that follows the OpenTelemetry Semantic Conventions for HTTP Spans.
Moesif treats each OpenTelemetry HTTP request/response span as an API event and maps spans to Moesif’s API event model. This allows Moesif to capture key information like request and response details, user identification, and metadata. Each span maps to a single API event, either an API call or a custom action. In addition, Moesif captures Trace ID, Span ID, Parent Span, Span Lin ks, and metadata.
For information about how Moesif maps different span elements, see Overview of Span Mapping.
Besides request and response spans, Moesif also supports the following:
- Span Events
- Custom Span Attributes
- Request and response bodies
- User, Company, and Subscription tracking
You can further leverage the OpenTelemetry data Moesif collects in different API and customer analytics.
Overview of Moesif Native Integrations
Moesif provides native SDKs, middlewares, and extensions for various frameworks, tools, and API gateways like the following:
- Node.js, Python, Java, .NET, Go
- API Gateways like Kong, AWS API Gateway, and NGINX
- Serverless environments like AWS Lambda, and Azure
Moesif native integrations automatically instrument your REST, GraphQL, XML/SOAP, RPC, and other APIs to send analytics data to Moesif. You can customize what data your API sends to Moesif and how. That data then becomes available for you to analyze, observe, and leverage in the Moesif platform across various feature suites. You can perform granular and powerful analytics, visualize them, manage your analysis in customizable dashboards, workspaces, and more.
Feature Comparison
The following table summarizes the key feature differences.
Feature | OpenTelemetry integration | Native integrations |
---|---|---|
Governance | Doesn’t support Moesif’s governance features, such as blocking or modifying API calls. | Supports governance features. |
Dynamic sampling | Doesn’t apply Moesif’s dynamic sampling to the OpenTelemetry data. You must configre sampling manually within your OpenTelemetry tooling. Then follow the instructions in Weight Attribute and Sampling to set the weight attribute. | Supports dynamic sampling. |
Capturing HTTP bodies | Supports through span attributes http.request.body and http.response.body |
Supports body capturing and is turned on by default. |
User, Company, and Subscription tracking | Supports through span attributes user.id , company.id , and subscription.id |
Supports through a user identification hook that you can implement in a Moesif SDK or middleware. |
Use Cases
When deciding to choose between the two integration types, consider whether or not you require telemetry data for your system’s observability. For example, you may be switching to Moesif from a previous approach where you had relied on telemetry data to observe your systems or services. Therefore, you already have OpenTelemetry-instrumented apps or systems. Using Moesif’s OpenTelemetry integration will help you simplify the migration while keeping your observability requirements and setups intact, without any redeployment or code changes.
Keep in mind that OpenTelemetry is a standardized observability framework. Moesif aims to bring its benefits to the Moesif platform where you already have a vast array of API and customer analytics features.
The following sections further clarify some relevant scenarios to help you better distinguish between the two and understand their benefits.
Why Choose Moesif’s OpenTelemetry Integration
Use it to achieve technical observability and performance monitoring in distributed systems.
- Distributed tracing in microservices architecture
- If you have a microservices architecture and instrumented it with OpenTelemetry, this integration helps you collect and analyze trace data across services.
- Debugging performance issues
- Using OpenTelemetry trace data, you can better troubleshoot performance issues like latency and slow API endpoints. By combining this with Moesif’s performance analytics and customizable alerting system, you can maintain proactivity and consistency in improving your apps and services.
- Engineering-centric insights
- For engineering teams focused on system reliability and performance, the OpenTelemetry integration provides deeper insights into how your system performs in production.
Why Choose Moesif Native Integrations
The native integrations offers more context and allow you to perform advanced API and customer-centric analysis.
- Tracking API usage and adoption
- Native integrations provide detailed metrics and context on API calls, endpoints, and usage patterns.
- Customer behavior analytics
- For product and growth teams, Moesif native integrations help you track customer
behavior and understand them. For example:
- Most used features
- Customers experiencin errors
- How API usage correlates with business outcomes
- Revenue and monetization insights
- If you’re monetizing your APIs, native integrations help you track usage-based revenue, identify high-value customers, and optimize pricing strategies.
- Business and product-led decision making
- Native integrations provide actionable insights into how your customers use your product and how it impacts user satisfaction, retention, and conversion.
Recommendations
Consider using both integrations so you get the best of both worlds in one platform: technical observability and customer-centric product analytics.
On the other hand, you may not need to have your OpenTelemetry data in Moesif and therefore choose not to use its OpenTelemetry integration. Rather, you may use an OpenTelemetry client with an observability backend like Jaegar and Prometheus. In that case, you can still use Moesif native integrations to leverage Moesif’s API and customer analytics features.