Property Data Types

Properties are configure within blueprint descriptors. 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 blueprint descriptor determines the kind of data that the property can store within an entity descriptor. 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 scorecard and automation 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 descriptor.
{
  // 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 descriptor.
{
  // 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.

How a "date-time" property looks like in a blueprint descriptor.
{
  // 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."
      }
    }
  }
}

Boolean

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

How a "boolean" looks like in a blueprint descriptor.
{
  // 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."
      }
    }
  }
}

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.

How a "URL" property looks like in a blueprint descriptor.
{
  // 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."
      }
    }
  }
}

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.

How a "json" property looks like in a blueprint descriptor.
{
  // 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."
      }
    }
  }
}

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.

How an "object" property looks like in a blueprint descriptor.
{
  // 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":"..."
                     }
                  }
               }
            }
         }
      }
   }
}

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.

How a "yaml" property looks like in a blueprint descriptor.
{
  // 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."
      }
    }
  }
}

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.

How a "markdown" property looks like in a blueprint descriptor.
{
  // 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."
      }
    }
  }
}

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.

How an "OpenAPI" property looks like in a blueprint descriptor.
{
  // 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."
      }
    }
  }
}

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.

How an "iframe" property looks like in a blueprint descriptor.
{
  // 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."
      }
    }
  }
}

Array

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

How an "array" property looks like in a blueprint descriptor.
{
  // Blueprint metadata
  ...
  // Blueprint Properties
  "schemaProperties": {
    "type": "object",
    "properties": {
      // My array property
      "my-array-property": {
        "type": "array",
        "format": null,
        "title": "My Array Property",
        "description": "..."
      }
    }
  }
}

Time Series Query

Time Series Query properties enable you to set up queries for retrieving metrics from external tools through your plugin integrations. Data retrieval occurs at scheduled intervals, but can also be immediately updated upon visiting a specific entity page featuring time-series properties.

To utilize this feature, it's essential to have compatible plugins (e.g., Grafana Cloud) installed. After selecting the desired plugin, you can craft your query using the querying language provided by the plugin's data source. For instance, Grafana's querying language can be employed to import metrics directly into your software catalog (refer to the Grafana documentation for more details).

Before submission, Rely conducts a real-time execution of the query to verify its functionality and to ensure it yields data in the correct format.

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 are designed to fetch specific data points from external tools via plugin integrations. The key difference lies in the expected result: Single Value Queries aim to return a singular data point as opposed to a series of data points over time.

To utilize this feature, it's essential to have compatible plugins (e.g., Grafana Cloud) installed. After selecting the desired plugin, you can craft your query using the querying language provided by the plugin's data source. For instance, Grafana's querying language can be employed to import metrics directly into your software catalog (refer to the Grafana documentation for more details).

Before submission, Rely conducts a real-time execution of the query to verify its functionality and to ensure it yields data in the correct format.

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

Reference Properties

Reference property allows you to mirror properties from related entities. When two blueprints have a relation between them, a new set of properties becomes available to entities in the "source" blueprint.

Learn More

Updating a Blueprint

Updating an Entity

Customising an Entity's page

PreviousBlueprintsNextCatalogs

Last updated