This tutorial shows how to use metrics information from io.Insights to answer questions about user and application behavior across your enterprise. It's a practical example of identifying the most frequently used applications in your io.Connect environment.
What You'll Learn
io.Insights publishes a rich set of information about the platform and applications running in it that can be used to investigate both individual entities (specific applications, workspaces, users, layouts) as well as generate aggregated reports about behavior and usage patterns.
When coupled with a querying system like Grafana, infrastructure and analytics teams can build dashboards, set up alerts, and run queries to gain visibility into a wide range of operational metrics.
Prerequisites
- io.Insights enabled and configured in your io.Connect environment – see https://docs.interop.io/insights/configuration/index.html
- Grafana connected to your OpenTelemetry metrics collector – see https://community.interop.io/t/getting-started-with-io-insights/55
- Access to Grafana dashboard creation
Step 1: Access Your Grafana Dashboard
Navigate to your Grafana instance and access the Dashboards section. You should see your existing dashboards, including any io.Insights dashboards you may have already created.
Click New to create a new dashboard -> New Dashboard, then select + Add visualization to begin building your metrics query.
Step 2: Create a New Visualization Panel
You'll start with a blank panel configuration. The key to this demonstration is using data from the app_started metric, which represents the number of times each application has been started during platform sessions.
In the metrics selection dropdown, you'll see various io.Insights metrics available, including:
-
app_started_total- our target metric -
app_duration_*- application focus time metrics -
app_memory_*- memory usage metrics -
platform_startup_*- platform initialization metrics
Select app_started_total as your primary metric.
Step 3: Switch to Bar Chart Visualization
For displaying top applications by usage count, a bar chart provides clearer insights than a time series. Change your visualization type to Bar gauge in the panel options.
This creates a much more readable view showing each application and its relative usage frequency.
Step 4: Configure the Query and Aggregation
Since we want to identify the most-used applications based on total startup counts, we need to apply aggregation. The app_started metric is an increasing counter, so we're interested in the maximum value it reaches for each application.
Configure your query settings:
- Metric: app_started_total
- Aggregation: Select Max over time since we want the total count per application
- Group by: Application name (this will separate results by individual applications). Aggregations -> Max by -> application -> instance
- Sum: get total runs per applications 3.gregations* -> Sum -> by label -> application
Click Run queries
Step 5: Add Data Transformations
To make the data more presentable and show only the top results, we'll add transformations. Click on the Transformations tab to access additional data processing options.
The transformations allow you to:
- Limit results: Show only the top N applications
- Sort data: Order by usage count (descending)
- Rename fields: Clean up display names
- Calculate values: Perform additional aggregations
- Group by nested tables: If you want to organize by additional attributes
This ensures you're displaying the most actionable data and the applications that are actually being used most frequently by your users..
Step 6: Review Your Results
Your final visualization should clearly show which io.Connect applications are used most frequently in your environment. This information can help you:
- Identify popular applications for optimization or additional investment
- Spot underutilized applications that may need better promotion or could be candidates for removal
- Plan infrastructure capacity based on actual usage patterns
- Make data-driven decisions about application portfolio management
Beyond This Example
This demonstration shows just a simple example of extracting metrics information in a few clicks. Experienced analysts can build extremely sophisticated dashboards that include:
- Regional breakdowns: Most used applications per geographic region
- Version analysis: Usage patterns across different application versions
- Time-based trends: Usage changes over specific periods
- User behavior analysis: Individual user application preferences
- Performance correlations: Connecting usage data with performance metrics
Key Insights from io.Insights Data
All the telemetry information published by io.Insights describes events that occur in your applications and platform. This data can optionally be exported as metrics, giving you instant visibility into any aspect of your application usage related to the features of the io.Connect platform.
The app_started metric used in this example is just one of many available metrics. Other valuable metrics include:
- app_duration: The time an app has been on focus during each platform session.
- app_error: The number of times an app error was received during each platform session.
- workspace_stopped: The number of times a Workspace has been stopped during each platform session.
- system_cpu and system_memory: Resource utilization patterns
Next Steps
From this foundation, you can:
- Save the query for future use and monitoring
- Set up alerts when usage patterns change significantly
- Add the panel to a dashboard with other related metrics
- Create additional breakdowns by user, time period, or platform version
- Export data for further analysis in other tools
This approach transforms raw telemetry data into actionable business intelligence, helping you optimize your io.Connect deployment based on real user behavior.
Useful links
Top comments (0)