Motadata’s Tag Management helps teams organize and contextualize observability data across monitors and infrastructure components. By applying tags to monitors and instances, you can filter, group, and analyze data more effectively across dashboards, alerts, topology, reports, and policies. This improves visibility, simplifies investigation, and helps teams manage complex environments with greater clarity and control.
In Motadata ObserveOps, tags are a fundamental form of metadata that you assign to your monitors. Think of them as customizable labels that provide extra context and categorization to your infrastructure elements. A tag can be a simple, standalone label, or it can be a more detailed key-value pair, offering flexibility in how you describe your resources.
Tags are designed to help you organize, filter, and analyze your IT resources more effectively. By associating tags with different monitors, you gain a deeper understanding of the relationships between various components of your infrastructure. This enhanced understanding streamlines your monitoring processes, allowing you to quickly identify and address issues, optimize performance, and improve overall management of your environment.
Motadata ObserveOps supports two primary types of tags, each serving a distinct purpose:
A simple value tag is a basic label or identifier that doesn’t have a value associated with it. It’s a single-word descriptor.
They’re used to categorize monitors based on a specific, singular characteristic. Think of them as binary flags: either the monitor has this attribute, or it doesn’t.
Simple value tags are most useful when you just need to indicate the presence or absence of a particular attribute. They provide a basic level of categorization.
Limitation: They are primarily designed for filtering. They allow you to include or exclude monitors from a view or analysis.
Examples: “AWS EC2”, “Azure VM”, “vCenter”. These tags tell you the type of resource.
A key-value tag consists of a label (the “key”) and an associated value, separated by a colon (e.g., “Environment: Production”).
They provide a more detailed and flexible way to categorize your resources, allowing you to assign specific attributes or properties to your monitors.
Key-value tags enable more nuanced classification. They go beyond simple presence/absence and provide specific details.
Capability: They can be used for both filtering and grouping monitors. This dual functionality makes them more powerful.
Examples: “Environment: Development”, “Environment: Production”, “Application: CRM”, “Application: Web Server”. These tags provide context (Environment, Application) and specifics (Development, Production, CRM, Web Server).
It’s crucial to distinguish between groups and tags in Motadata ObserveOps, as they serve different, though complementary, roles:
Purpose: To establish logical boundaries between monitors, often for access control or organizational hierarchy.
Structure: Hierarchical, arranged in a tree-like structure. They apply only to monitors.
Scalability: Can become difficult to manage at a large scale due to their hierarchical nature, requiring careful planning and maintenance.
Usage: Primarily used for data security (restricting access to certain groups of monitors) and Role-Based Access Control (RBAC), defining what actions users can perform on those groups.
Purpose: Tailored for specific user needs and custom use-cases, offering a high degree of flexibility in how you categorize and organize your resources.
Structure: Flat, a simple list of labels. They can be applied to both monitors and individual instances of monitors, providing fine-grained control.
Scalability: Easy to scale to very large environments if managed with consistent naming conventions and a clear strategy.
Usage: The fundamental building blocks for organizing, filtering, and analyzing your resources. They are the primary way to add custom metadata.
Implementing a tagging strategy in Motadata ObserveOps offers several key advantages for managing your monitoring environment:
Tags allow you to group your monitored resources logically, based on criteria that are meaningful to your business.
This makes it significantly easier to locate and manage specific elements within your infrastructure, especially as your environment grows in complexity.
Tags provide you with better insight into the various aspects of your environment, beyond basic device type or location.
They act as a powerful categorization tool, allowing you to slice and dice your monitoring data in numerous ways.
Tags help you focus on specific subsets of data during your analysis, enabling you to quickly identify trends, patterns, and anomalies.
Tags provide a structured way to filter and search for resources, making it faster to find the information you need.
This is especially valuable in large-scale deployments, where manually sifting through data is time-consuming and impractical.
By narrowing your focus, tags enable more efficient analysis, leading to quicker problem resolution and better decision-making.
Tags in Motadata ObserveOps are incredibly versatile and can be applied to a wide range of scenarios. Here are some common use cases to illustrate their power:
Use Case 1: Organizing Servers by Function (e.g., “Production”, “Development”, “Finance”). This allows you to quickly see all servers related to a specific business function.
Use Case 2: Geographic Location (e.g., “US-West”, “EU-Central”, “APAC”). This is useful for geographically distributed environments.
Use Case 3: Application Classification (e.g., “CRM”, “ERP”, “Web Server”, “Database”). This helps you monitor the infrastructure supporting specific applications.
Use Case 4: Differentiating Environments (e.g., “Development”, “Testing”, “Staging”, “Production”). This allows you to tailor monitoring to the specific lifecycle stage.
Use Case 5: Identifying Core Services (e.g., “Email Service”, “File Storage”, “Backup Service”). This helps you track the health of critical services.
Use Case 6: Network Segmentation (e.g., “Data Center A”, “Branch Office B”, “Network Segment 1”). This is useful for network-focused monitoring.
Use Case 7: Prioritizing Monitoring Efforts (e.g., “Critical”, “High”, “Medium”, “Low”). This ensures that you focus on the most important systems.
Use Case 8: Facilitating Ownership and Collaboration (e.g., “Team-A”, “Team-B”, “Individual-Owner”). This helps with accountability and communication.
Use Case 9: Vendor-Related Resource Tracking (e.g., “Vendor-X”, “Supplier-Y”). This is useful for managing vendor relationships and tracking vendor-specific issues.
Motadata ObserveOps provides several flexible methods for assigning tags to your monitors:
During the device discovery process, allowing you to tag resources as they are brought into the system.
In the monitor settings for devices that have already been discovered and are actively being monitored.
Directly at the individual instance level of a monitor, providing very granular control for specific situations.
Here are the detailed steps for each method:
When you create a discovery profile, which defines how Motadata ObserveOps discovers devices on your network, you can select or create tags to be assigned to the devices that are discovered. This is the most efficient way to tag new resources.
Once the discovery process is complete, the tags are automatically assigned to the provisioned monitors, without any further manual intervention.
For monitors that are already being managed by Motadata ObserveOps, you can assign tags by navigating to the Monitor Settings.
First, go to the Monitor Settings section of the Motadata AIOps interface.
Then, select the specific type of monitor you want to work with (e.g., Device, Cloud, Agent, Service Check), as monitor settings are often type-specific.
Edit the specific monitor you want to tag. This will open the monitor’s configuration page.
In the monitor’s edit screen, you can select existing tags from a dropdown menu, or you can create new tags by typing them directly into the tag field. New tags are typically saved for later use.
In some cases, you may need to assign tags to individual instances* of a monitor, rather than to the monitor as a whole. For example, if you are monitoring a server with multiple hard drives, you might want to tag each hard drive instance with its specific location or function.
* To do this, select the Instance Count for the monitor. This will take you to a view where you can see the individual instances.
* Then, you can select or create tags at the instance level, allowing you to differentiate between the instances.
Tags are deeply integrated into the Motadata ObserveOps platform, enhancing the functionality of many of its features and providing a consistent way to work with your monitoring data:
Tags play a key role in how data is displayed and interacted with on your dashboards and widgets, providing dynamic filtering and grouping.
They provide both filtering and grouping capabilities, allowing you to customize your views and gain targeted insights.
When configuring a widget, use the “Source Filter” option to narrow down the data that is displayed.
Select “Tag” as the source filter. This tells the widget to use tags as the basis for filtering.
Choose the specific tags (either simple value tags or key-value tags) that you want to use for filtering. The widget will then only show data related to monitors that have those tags.
In the “Result By” column of the widget configuration, select “Tag”.
This instructs the widget to organize the displayed data based on the selected tags. Monitors with the same tag values will be grouped together.
Example Scenario: You can create a dashboard widget to visualize the availability of your servers, and then use tags to filter the view to only show servers in specific regions (e.g., “US-West”, “EU-Central”) and group the results by those regions. This gives you a clear, organized view of regional availability.
When viewing your monitors in a list format, the “Tags” column displays the tags that have been assigned to each monitor, providing a quick overview of how your monitors are categorized.
In a monitor’s template view, which provides detailed information about the monitor’s configuration, you can use the “Tag Info” dropdown to see the difference between User tags (tags that you have manually assigned) and System tags (tags that are automatically assigned by Motadata ObserveOps).
To quickly find specific monitors, click on the filter icon (usually represented by a funnel icon).
Select the tags you want to use for filtering. The monitor list will then be updated to show only the monitors that have those tags.
Example: You can filter the monitor list to view only AWS servers by selecting the “AWS” tag.
Similar to the Monitor Screen, the “Tags” column in the Alert Screen shows you the tags associated with each alert. This includes tags from both the alert policy that triggered the alert and the tags of the affected monitors.
When you drill down into a specific alert to see its details, the tags assigned to the alert are also displayed, providing context about the alert’s source.
You can filter the alert list using tags to focus on specific types of alerts. Click on the filter icon.
Select the tags you want to use for filtering. The alert list will then be updated to show only the alerts that match those tags.
Example: You can filter the alert list to see only alerts related to monitors in a specific location, such as “location:Delhi”.
When you are visualizing your network topology in Motadata AIOps, selecting monitors on the map will instantly display their assigned tags, providing on-the-fly context about the selected devices and their relationships within the network.
Reports:
When you are creating a custom report, you can use tags to filter the data that is included in the report.
Select “Tag” as the source filter in the report configuration.
Then, choose the specific tags you want to use to filter the data. The report will then only include data from monitors that have those tags.
Example Scenario: You can create a report showing the availability of servers in a specific location by filtering the report data using a location tag.
When you are configuring a monitoring policy (which defines the conditions that trigger alerts), you can use tags to specify which monitors the policy applies to.
Use “Tags” as the source filter in the policy configuration to narrow down the scope of the policy.
Example Scenario: You can configure a policy to apply only to servers in your production environment by using an “Environment: Production” tag.
You can also assign tags directly to monitoring policies themselves.
These tags are then associated with both the policy and any alerts that are triggered by that policy, providing a consistent way to categorize and manage your policies and alerts.
When you are working with credential profiles (which store authentication information for accessing devices), you can view the monitors that have been discovered using a particular profile.
You can then filter this list of monitors by their tags to find specific devices.
Example Scenario: You can identify all AWS monitors that were discovered using a specific AWS credential profile by filtering the monitor list by the “AWS” tag.
See the “Assigning Tags During Device Discovery” section for information on how tags are used during the device discovery process.
In the Device/Cloud/Agent/Service Check Monitor Settings, the “TAGS” field displays all tags that are currently assigned to a monitor, giving you a quick overview of its categorization.
You can add or remove tags from existing monitors directly within these settings, allowing you to modify their categorization as your needs evolve.
You can also manage tags at the instance level, providing fine-grained control over how individual components of a monitor are tagged.
The filter option in these settings allows you to quickly find specific monitors based on their assigned tags.
Example: You can filter the monitor list to identify all servers in your development environment by using the “env:dev” tag.
*Viewing Associated Monitors and Tags from Used Count field.
*Viewing Associated Monitors and Tags from Devices field.
*Viewing Associated Monitors and Tags from Used Counts field.
*Viewing Associated Monitors and Tags for Runbook, Metric, and Topology from the Monitor tab in the Used Counts field.
Motadata ObserveOps also provides rule-based tagging, a powerful feature that automates the process of assigning and removing tags based on predefined criteria. This automation significantly reduces the manual effort associated with tag management, especially in dynamic environments. Rule-based tagging can be applied to a wide range of entities within Motadata AIOps, including:
Monitors
VMs (Virtual Machines)
Applications
Processes
Services
IP SLA (IP Service Level Agreement)
Interfaces
Rule-based tagging eliminates the need for manual intervention in many common tagging scenarios.
Supports static tags: You can create rules to assign tags with fixed values.
Supports key-value pair tags: Rules can create tags with both a key and a value.
Supports dynamic tags: You can use metric counter values to dynamically populate the value of a tag, allowing tags to reflect real-time system information.
Allows you to define up to ten conditions based on metric counters: Rules can be very precise, applying tags only when specific performance or health metrics meet your criteria.
Uses a one-to-one mapping between rules and tags: Each rule is associated with a single tag. If you need to assign multiple tags, you’ll create multiple rules.
The configuration interface for Rule Based Tags is located within the System Settings section of Motadata ObserveOps.
This screen provides a centralized view of all the tagging rules you have configured. Key fields displayed on this screen include:
Rule Name: A descriptive name for the rule.
Description: A detailed explanation of the rule’s purpose and the entities it affects.
Operation: Indicates whether the rule is used to “Assign” or “Remove” tags.
Used Count: The number of devices or entities that are currently associated with the rule (i.e., the number of entities to which the rule is applying tags).
Tag: The tag that is being assigned or removed by the rule.
Last Ran At: The timestamp of the last time the rule was executed.
From this screen, you can also perform the following actions on existing rules:
Manually execute a rule: Force the rule to run immediately, outside of its scheduled execution.
Delete a rule: Remove the rule from the system. It’s important to note that deleting a rule does not automatically remove the tags that were applied by that rule. You will need to create a separate rule to remove those tags if desired.
When you create a new rule for automated tag management, you’ll configure the following options:
Rule Name: A unique and descriptive name for the rule.
Description: A clear and detailed explanation of the rule’s purpose, including what types of devices or entities it applies to.
Rule Applies to: Select the type of device or entity that the rule will affect (e.g., Monitor, VM, Application).
Tag Operation: Specify whether the rule should “Assign” tags or “Remove” tags.
Key: Enter the key for the tag you want to assign or remove. For simple value tags, you would enter the tag name here.
Value: Enter the value for the tag. This field supports both static and dynamic values:
Static values: A fixed string that will be the same for all tagged entities.
Dynamic values: You can use a metric counter name enclosed in curly brackets {} to dynamically populate the tag value with real-time data. For example, {instance.type.per.sec} would use the value of the “instance.type.per.sec” counter.
Condition: This is where you define the criteria that must be met for the rule to be applied. See the “Configuring Conditions” section below for details.
Rule-based tagging allows you to define very precise conditions based on metric counters. A rule will only be applied (i.e., a tag will only be assigned or removed) when these conditions are met. You can define multiple conditions within a single rule, allowing for complex logic. The parameters for each condition include:
Group Matching: Specify whether to “Include” or “Exclude” devices that match the condition:
Include: The rule will apply to devices that do match the condition.
Exclude: The rule will apply to devices that do not match the condition.
Counter: Select the specific metric counter that you want to use in the condition (e.g., CPU utilization, memory usage).
Operator: Choose an operator from the dropdown menu to define the relationship between the counter and the value (e.g., “=”, “>”, “<“, “>=”, “<=”).
Value: Enter the value that you want to compare against the metric counter.
AND/OR: If you define multiple conditions, use “AND” or “OR” to specify how they are combined:
AND: All conditions must be true for the rule to apply.
OR: At least one condition must be true for the rule to apply.
You can add more conditions to a rule by clicking the “Add Condition” button, allowing you to create complex tagging logic.
The Rule Criteria section displays the rule condition query in its raw format, using a query language. This is helpful for advanced users who want to understand exactly how the rule is being processed and executed by the system. It provides transparency into the rule’s logic.
Once you have configured a rule, you can perform the following actions:
Create Rule: Save the rule and activate it.
Preview: See a list of the devices or entities that currently meet the rule’s conditions. This allows you to verify that the rule will apply to the correct set of resources before you save it.
Reset: Clear all the fields in the rule configuration form and start over.
To maximize the effectiveness of tagging in Motadata AIOps and maintain a well-organized and efficient monitoring environment, follow these best practices:
Before you start creating tags, develop a comprehensive plan for how tags will be used throughout your organization. A well-defined strategy is essential for consistent and effective tag management.
Use the provided tag categories (Server Tags, Application Tags, etc.) as a starting point for brainstorming and planning.
Tailor your tagging strategy to align with the unique needs, workflows, and organizational structure of your company. There is no one-size-fits-all approach.
Focus on enabling effective resource filtering and grouping, which are the primary benefits of a good tagging strategy.
Examples of Tag Usage Strategies:
Server Tags: Define a consistent scheme for tagging servers. Consider using tags for:
Function: “Production”, “Development”, “Finance”
Location: “US-West”, “EU-Central”
Department: “Sales”, “Engineering”
Ownership: “TeamA”, “TeamB”
Application Tags: Tag resources based on the applications they support:
“CRM”, “ERP”, “Web Server”, “Database”
Environment Tags: Differentiate between lifecycle stages:
“Development”, “Testing”, “Staging”, “Production”
Service Tags: Classify resources based on the services they provide:
“Email Service”, “File Storage”, “Backup Service”
Location Tags: Organize resources by physical or logical location:
“Data Center A”, “Branch Office B”, “Network Segment 1”
Criticality Tags: Indicate the importance of resources:
“Critical”, “High”, “Medium”, “Low”
Team/Owner Tags: Identify responsible parties:
“Team-A”, “Team-B”, “Individual-Owner”
Vendor Tags: Track vendor-related resources:
“Vendor-X”, “Supplier-Y”
Establish and enforce clear and consistent naming conventions for your tags. This is crucial for avoiding confusion and ensuring that tags are used uniformly across the organization.
Make sure that tag names are intuitive and clearly reflect their purpose and the category they represent. Short, descriptive names are generally best.
Create and maintain comprehensive documentation that outlines how tags should be used within your organization. This documentation should be easily accessible to all relevant personnel.
Clearly communicate the purpose of each tag category and the specific criteria for assigning tags. Provide examples to illustrate correct usage.
Periodically review your existing tags to ensure they are still relevant, accurate, and being used correctly. Tag usage can drift over time, so regular audits are important.
Remove any obsolete or unused tags to maintain a clean and efficient tagging structure. A cluttered tagging system is difficult to manage and can lead to errors.
Use tags judiciously. While tags are powerful, over-tagging can create unnecessary clutter and make it harder to find the information you need.
Prioritize the most essential tags that provide the most valuable insights for your monitoring and management needs. Focus on quality over quantity.
Collaborate with different teams within your organization to understand their specific needs and requirements for grouping monitors. This ensures that groups are created in a way that aligns with actual workflows.
Create custom groups based on these discussions to ensure they accurately reflect your organizational structure and monitoring objectives.
Have a clear understanding of the differences between Groups and Tags, and design your overall resource organization strategy accordingly. Don’t try to use tags to replicate the hierarchical structure of groups.
Define clear and specific criteria for automatically assigning groups and tags to monitors during the device discovery process. This can significantly reduce manual
Discover how Motadata AIOps can help you monitor your infrastructure in real-time and respond to issues instantly.