Property Data Types

Properties are configured 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 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.

Time Series Property Display

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 Grafana documentation for more details).

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

Time Series Creation Form

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.

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 Grafana documentation.)

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

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

Property Actions

Updating a Blueprint

Property Actions

Updating an Entity

Property Actions

Customizing an Entity's page