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.

Next Steps

Updated: