Rely.io
  • 📌What is Rely.io?
  • 💡How Rely.io works
  • 📑Getting Started Guide
    • Create an account for your organization
    • Add your first plugin
    • Import services into the Service Catalog
    • Make the Software Catalog your own
    • What's Next?
  • 🌈Basic Concepts
    • Entities
    • Blueprints
    • Property Data Types
    • Catalogs
    • Data Model
    • Plugins
    • User Blueprints vs Plugin Blueprints
    • Actions and Automations
      • Automation Rules
      • Self-Service Actions
    • Home Pages
    • Scorecards
  • 📚Guides & Tutorials
    • Enhancing Deployment Visibility through Gitlab Pipelines and Rely's API
  • 🖥️Software Catalog
    • Overview and Use Cases
    • Usage Guide
      • Creating a new Entity
      • Updating an Entity
      • Tracking Entity Changes
      • Customizing an Entity's Page
      • Customizing a Catalog
      • Creating a new Blueprint & Catalog
      • Updating a Blueprint
      • Tracking Blueprint Changes
    • Relevant Guides
    • Troubleshooting
  • 🥇Scorecards
    • Overview and Use Cases
    • Usage Guide
      • Creating a Scorecard
      • Updating a Scorecard
      • Evaluating Performance
    • Scorecard Examples
      • Production Readiness Scorecard Example
      • DORA Metrics Scorecard Example
      • Operational Maturity Example
  • 🎨Home Pages
    • Overview and Use Cases
    • Usage Guide
      • Creating a New Tab
  • ⚡Self-Service Actions
    • Overview and Use Cases
    • Usage Guide
      • Configuring your Self Service Agent
      • Managing your Actions Catalog
      • Self-Service Actions as Code
      • Running Actions
      • Tracking Action Runs
  • ↗️Plugins & Automation
    • What happens when you install a Plugin?
    • Self-Hosting Plugins using Galaxy
    • 🤖Automation Rules
      • Overview and Use Cases
      • Usage Guide
        • Creating an Automation Rule
        • Updating an Automation Rule
        • Tracking Automation Changes
        • Managing Automation Suggestion
    • 🔌Plugin Installation Guides
      • ⭐AWS
      • Bitbucket
      • ⭐Flux
      • GitHub
      • GitLab
      • ⭐Google Cloud Platform (GCP)
      • ⭐Kubernetes
      • ⭐OpsGenie
      • ⭐PagerDuty
      • ⭐Snyk
      • ⭐SonarQube
  • 🌐Public API
    • Audit Logs
    • Automations & Self-Service Actions
    • Automation Suggestions
    • Blueprints
    • Dashboards & Views
    • Entities
    • Scorecards
    • Self-Service Action Runs
    • Time Series
    • Users
    • Webhooks
  • ⚙️Invite Users
  • 🛡️Security & Compliance
    • Single Sign-On (SSO)
      • SAML with Google Workspace
      • SAML with Microsoft Entra ID
      • SAML with Okta
      • OIDC with Okta
      • OIDC with Google Workspace
  • 🏥Troubleshooting
  • ❓FAQ
Powered by GitBook
On this page
  • String
  • Number
  • Date-Time
  • Boolean
  • URL
  • JSON
  • Object
  • YAML
  • Markdown
  • OpenAPI
  • Iframe
  • Array
  • Time Series Query
  • Single Value Query
  • Reference Properties
  • Learn More

Was this helpful?

  1. Basic Concepts

Property Data Types

PreviousBlueprintsNextCatalogs

Last updated 7 months ago

Was this helpful?

Properties are configured within . This is where you'll find and manage a property's id, title, descriptions and data type.

Property IDs need to be unique within a single blueprint, but properties in different blueprints can have similar IDs.

The data type specified in the determines the kind of data that the property can store within an . This affects how data is interpreted and displayed within Rely.

A property’s data-type in a blueprint is defined by a combination of two parameters: type and format.

The data type of a property determines the operators available for configuring and rules.

Below, we provide an overview of all the available data types, exploring their utility and how to configure them.

String

Strings represent text data. They are versatile and can include mostly anything from namespaces, statuses, etc.

How a "string" property looks like a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My string property
      "my-property-id": {
        "type": "string",
        "format": null
        "title": "My Property Title",
        "description": "..."
      }
}

Number

Numbers are used for numerical data, from quantities to identifiers.

How a "number" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My number property
      "my-number-property": {
        "type": "number",
        "format": null,
        "title": "My Number Property",
        "description": "A numeric property."
      }
    }
  }
}

Date-Time

This type is used for date values, ensuring events are accurately timestamped.

Boolean

Booleans represent binary choices, such as true/false or yes/no scenarios.

URL

URLs are used to store web addresses, linking to external resources. Here's some general considerations to keep in mind:

  • Validation: When assigning values to URL properties, only valid URLs will be accepted. This ensures that the links are functional and lead to actual resources.

  • Display Simplification: To maintain clarity and prevent clutter in the web application, Rely.io simplifies the display of URLs. Instead of showing the full URL, which can be lengthy and cumbersome, only the domain name is displayed. This approach keeps the interface clean and focused, without sacrificing access to the full URL.

JSON

JSON properties in Rely offer a flexible solution for storing unstructured data. These properties accept JSON payloads without the need for a predefined schema, accommodating a wide range of data representations.

The payload for JSON properties is sanitised upon storage to ensure security and integrity, allowing for a versatile and "everything goes" approach to data storage - as long as it's a valid JSON.

Object

Object properties in Rely are designed for structured data storage, enabling the representation of complex, nested information structures. These properties require users to define a clear schema beforehand, which outlines the specific structure and type of data that the object will hold.

This pre-specification of schema ensures that any data stored in or updated to an object property strictly adheres to the defined structure, maintaining data integrity and consistency across your entities.

YAML

YAML is ideal for configuration data, favoured for its readability.

The payload for such properties is sanitised upon storage to ensure security and integrity, allowing for a versatile and "everything goes" approach to data storage - as long as it's a valid YAML.

Markdown

Markdown properties are used for text that includes formatting, such as documentation or notes.

The payload for such properties is sanitised upon storage to ensure security and integrity, allowing for a versatile and "everything goes" approach to data storage.

OpenAPI

OpenAPI properties should be set to a URL pointing to a valid OpenAPI JSON schema. The display will render the API specification as Swagger documentation.

Iframe

Iframe properties need to be set to URL pointing to a webpage. The display will render the webpage itself, embedding it directly within Rely.

Array

Arrays are used to store lists of values, which can be of any basic data type.

Time Series Query

Time Series Query properties allow you to set up queries for retrieving metrics from external tools through plugin integrations. Data retrieval happens at scheduled intervals, but can also update immediately when visiting a specific entity page with time-series properties.

It is recommended that you define these property types via the UI.

Single Value Query

Similar to Time Series Query properties, Single Value Query properties fetch specific data points from external tools via plugin integrations. The key difference is in the expected result: Single Value Queries return a single data point, rather than a series of data points over time.

It is recommended that you define these property types via the UI.

Reference Properties

A reference property allows you to mirror properties from related entities. When two blueprints have a relationship, a new set of properties becomes available to entities in the "source" blueprint.

Learn More

How a "date-time" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My date-time property
      "my-datetime-property": {
        "type": "string",
        "format": "date-time",
        "title": "My DateTime Property",
        "description": "A property for date and time."
      }
    }
  }
}
How a "boolean" looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My boolean property
      "my-boolean-property": {
        "type": "boolean",
        "format": null,
        "title": "My Boolean Property",
        "description": "A true or false property."
      }
    }
  }
}
How a "URL" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My URL property
      "my-url-property": {
        "type": "string",
        "format": "url",
        "title": "My URL Property",
        "description": "A property for web addresses."
      }
    }
  }
}
How a "json" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My JSON property
      "my-json-property": {
        "type": "string",
        "format": "json",
        "title": "My JSON Property",
        "description": "A property for JSON data."
      }
    }
  }
}
How an "object" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
   "schemaProperties":{
      "type":"object",
      "properties":{
          // My Object property
         "my-object-property":{
            "type":"object",
            "format":null,
            "title":"My Object Property",
            "description":"...",
            // My Object Schema 
            "properties":{
               "first-shcmea-prop":{
                  "type":"string",
                  "title":"My First Prop",
                  "description":""
               },
               "second-schema-prop":{
                  "type":"object",
                  "title":"My Second Prop",
                  "description":"...",
                  "properties":{
                     "nested-prop":{
                        "type":"string",
                        "title":"A nested prop",
                        "description":"..."
                     }
                  }
               }
            }
         }
      }
   }
}
How a "yaml" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My YAML property
      "my-yaml-property": {
        "type": "string",
        "format": "yaml",
        "title": "My YAML Property",
        "description": "A property for YAML data."
      }
    }
  }
}
How a "markdown" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My markdown property
      "my-markdown-property": {
        "type": "string",
        "format": "markdown",
        "title": "My Markdown Property",
        "description": "A property for Markdown text."
      }
    }
  }
}
How an "OpenAPI" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My OpenAPI property
      "my-openapi-property": {
        "type": "string",
        "format": "url/openApi",
        "title": "My OpenAPI Property",
        "description": "A URL to an OpenAPI specification."
      }
    }
  }
}
How an "iframe" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My iframe property
      "my-iframe-property": {
        "type": "string",
        "format": "url/iframe",
        "title": "My Iframe Property",
        "description": "A URL to a webpage for iframe embedding."
      }
    }
  }
}
How an "array" property looks like in a .
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My array property
      "my-array-property": {
        "type": "array",
        "format": null,
        "title": "My Array Property",
        "description": "..."
      }
    }
  }
}

To use this feature, you need compatible plugins (such as Grafana Cloud) installed. Once you've selected a plugin, you can create your query using the querying language provided by the plugin's data source. For example, you can use Grafana's querying language to import metrics directly into your software catalog (see the for more details).

Before submitting, runs the query in real-time to check its functionality and ensure it produces data in the correct format.

To use this feature, you need compatible plugins (such as Grafana Cloud) installed. After choosing a plugin, you can create your query using the plugin's data source querying language. For example, you can use Grafana's querying language to import metrics directly into your software catalog. (For more details, see the .)

Before submitting, runs the query in real-time to check its functionality and ensure it produces data in the correct format.

Property Actions
Property Actions
Property Actions
🌈
Grafana documentation
Rely.io
Grafana documentation
Rely.io
scorecard
automation

Updating a Blueprint
Updating an Entity
Customizing an Entity's page
blueprint descriptor
blueprint descriptor
blueprint descriptor
blueprint descriptor
blueprint descriptor
blueprint descriptor
blueprint descriptor
blueprint descriptor
blueprint descriptor
blueprint descriptor
blueprint descriptors
blueprint descriptor
blueprint descriptor
blueprint descriptor
entity descriptor
Time Series Property Display
Time Series Creation Form