Retrigger ScheduledExposureCalculation

POST

scheduledExposureCalculations

{scheduledExposureCalculation}

:retrigger

curl --request POST \
  --url https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "retriggerDependentMetricSchedules": true
}
'

import requests

url = "https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger"

payload = { "retriggerDependentMetricSchedules": True }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({retriggerDependentMetricSchedules: true})
};

fetch('https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'retriggerDependentMetricSchedules' => true
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger"

	payload := strings.NewReader("{\n  \"retriggerDependentMetricSchedules\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"retriggerDependentMetricSchedules\": true\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"retriggerDependentMetricSchedules\": true\n}"

response = http.request(request)
puts response.read_body

{
  "exposureCalculationSpec": {
    "assignmentTable": "<string>",
    "assignmentFilter": {
      "criteria": [
        {}
      ],
      "expression": {
        "ref": "<string>",
        "not": {},
        "and": {
          "operands": [
            {}
          ]
        },
        "or": {
          "operands": [
            {}
          ]
        }
      }
    },
    "exposureKey": "<string>",
    "groups": [
      {
        "group": "<string>",
        "variantKey": "<string>"
      }
    ],
    "splitDimensions": [
      "<string>"
    ],
    "exposureFilter": {
      "factTable": "<string>",
      "filter": {
        "criteria": [
          {}
        ],
        "expression": {
          "ref": "<string>",
          "not": {},
          "and": {
            "operands": [
              {}
            ]
          },
          "or": {
            "operands": [
              {}
            ]
          }
        }
      },
      "displayName": "<string>"
    },
    "filters": [
      {
        "factTable": "<string>",
        "filter": {
          "criteria": [
            {}
          ],
          "expression": {
            "ref": "<string>",
            "not": {},
            "and": {
              "operands": [
                {}
              ]
            },
            "or": {
              "operands": [
                {}
              ]
            }
          }
        },
        "displayName": "<string>"
      }
    ],
    "entityFilter": {
      "dimensionTable": "<string>",
      "filter": {
        "criteria": [
          {}
        ],
        "expression": {
          "ref": "<string>",
          "not": {},
          "and": {
            "operands": [
              {}
            ]
          },
          "or": {
            "operands": [
              {}
            ]
          }
        }
      }
    },
    "entityFilters": [
      {
        "dimensionTable": "<string>",
        "filter": {
          "criteria": [
            {}
          ],
          "expression": {
            "ref": "<string>",
            "not": {},
            "and": {
              "operands": [
                {}
              ]
            },
            "or": {
              "operands": [
                {}
              ]
            }
          }
        }
      }
    ]
  },
  "scheduleStartTime": {},
  "scheduleIntervals": [
    {}
  ],
  "entity": "<string>",
  "nextAssignmentStartTime": {},
  "nextAssignmentEndTime": {},
  "nextScheduledRunTime": {},
  "executedCalculationsCount": {},
  "iteration": {},
  "createTime": {},
  "updateTime": {},
  "status": {
    "scheduled": {
      "nextScheduleTime": {}
    },
    "cancelled": {
      "cancelledTime": {}
    },
    "calculating": {
      "exposureCalculation": "<string>"
    },
    "waiting": {
      "needDataUntilTime": {},
      "assignmentTable": "<string>",
      "factTable": "<string>",
      "dataDeliveredUntilTime": {}
    },
    "error": {
      "errorMessage": "<string>"
    }
  },
  "creator": "<string>",
  "updater": "<string>",
  "name": "<string>",
  "scheduleEndTime": {},
  "exposureTable": "<string>",
  "state": "STATE_UNSPECIFIED",
  "exposedEntitiesMetric": "<string>",
  "exposedEntitiesMetricSchedule": "<string>",
  "labels": [
    {}
  ],
  "activeRetrigger": "<string>",
  "displayName": "<string>",
  "owner": "<string>"
}

Authorizations

Authorization

string

header

required

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Path Parameters

scheduledExposureCalculation

string

required

Body

application/json

retriggerDependentMetricSchedules

boolean

If all the active metric that depend on this exposure schedule should also be retriggered

Response

200 - application/json

Returns a ScheduledExposureCalculation.

Represents the schedule of a exposure calculation.

exposureCalculationSpec

object

required

Defines how to calculate exposure.

Show child attributes

scheduleStartTime

object

required

The timestamp of when the schedule should start running.

scheduleIntervals

object[]

required

Length of the scheduling intervals, incremented each time the schedule runs until the last which is the length that is continued indefinitely.

entity

string

required

Resource name of the entity that is being exposed.

nextAssignmentStartTime

object

required

The start time of assignments for the next scheduled run.

nextAssignmentEndTime

object

required

The end time of assignments for the next scheduled run.

nextScheduledRunTime

object

required

The time when the exposure calculation is scheduled to run the next time. If the calculation is cancelled, this field contains the latest time it was scheduled to run before cancellation.

executedCalculationsCount

object

required

The number of calculations that has been executed so far.

iteration

object

required

The iteration of the schedule. A new iteration is created every time the schedule is retriggered.

createTime

object

required

Time when the scheduled exposure calculation was first created.

updateTime

object

required

Time when the scheduled exposure calculation was last updated.

status

object

required

Status of the schedule. This explains more in depth of where the schedule is now, if it's waiting for data or if it's currently executing

Show child attributes

creator

string

required

Reference to the identity that created this scheduled exposure calculation.

updater

string

required

Reference to the identity that last updated this scheduled exposure calculation.

name

string

Unique identifier of the scheduled exposure calculation. For example: scheduledExposureCalculations/0smva5nxuhv4yts6paxt

scheduleEndTime

object

The time when the exposure calculation will end. Once the schedule reaches the end it will be cancelled and no new calculations will be triggered. If no end is specified the schedule will continue indefinitely.

exposureTable

string

Resource name of the exposure table.

state

enum<string>

Current state of the schedule.

Available options:

STATE_UNSPECIFIED,

ACTIVE,

CANCELLED

exposedEntitiesMetric

string

Resource name of the metric that counts exposures.

exposedEntitiesMetricSchedule

string

Resource name of the metric schedule that counts exposures.

labels

object[]

Custom labels for this scheduled exposure calculation.

Show child attributes

activeRetrigger

string

Reference to a retrigger if one is active.

displayName

string

The human readable name of this schedule. If set it will be copied to the exposure_table and exposed_entities_metric.

owner

string

The owner of the resource. If not set will default to the creator.

⌘I

Retrigger ScheduledExposureCalculation

curl --request POST \
  --url https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "retriggerDependentMetricSchedules": true
}
'

import requests

url = "https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger"

payload = { "retriggerDependentMetricSchedules": True }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({retriggerDependentMetricSchedules: true})
};

fetch('https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'retriggerDependentMetricSchedules' => true
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger"

	payload := strings.NewReader("{\n  \"retriggerDependentMetricSchedules\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"retriggerDependentMetricSchedules\": true\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://metrics.eu.confidence.dev/v1/scheduledExposureCalculations/{scheduledExposureCalculation}:retrigger")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"retriggerDependentMetricSchedules\": true\n}"

response = http.request(request)
puts response.read_body

{
  "exposureCalculationSpec": {
    "assignmentTable": "<string>",
    "assignmentFilter": {
      "criteria": [
        {}
      ],
      "expression": {
        "ref": "<string>",
        "not": {},
        "and": {
          "operands": [
            {}
          ]
        },
        "or": {
          "operands": [
            {}
          ]
        }
      }
    },
    "exposureKey": "<string>",
    "groups": [
      {
        "group": "<string>",
        "variantKey": "<string>"
      }
    ],
    "splitDimensions": [
      "<string>"
    ],
    "exposureFilter": {
      "factTable": "<string>",
      "filter": {
        "criteria": [
          {}
        ],
        "expression": {
          "ref": "<string>",
          "not": {},
          "and": {
            "operands": [
              {}
            ]
          },
          "or": {
            "operands": [
              {}
            ]
          }
        }
      },
      "displayName": "<string>"
    },
    "filters": [
      {
        "factTable": "<string>",
        "filter": {
          "criteria": [
            {}
          ],
          "expression": {
            "ref": "<string>",
            "not": {},
            "and": {
              "operands": [
                {}
              ]
            },
            "or": {
              "operands": [
                {}
              ]
            }
          }
        },
        "displayName": "<string>"
      }
    ],
    "entityFilter": {
      "dimensionTable": "<string>",
      "filter": {
        "criteria": [
          {}
        ],
        "expression": {
          "ref": "<string>",
          "not": {},
          "and": {
            "operands": [
              {}
            ]
          },
          "or": {
            "operands": [
              {}
            ]
          }
        }
      }
    },
    "entityFilters": [
      {
        "dimensionTable": "<string>",
        "filter": {
          "criteria": [
            {}
          ],
          "expression": {
            "ref": "<string>",
            "not": {},
            "and": {
              "operands": [
                {}
              ]
            },
            "or": {
              "operands": [
                {}
              ]
            }
          }
        }
      }
    ]
  },
  "scheduleStartTime": {},
  "scheduleIntervals": [
    {}
  ],
  "entity": "<string>",
  "nextAssignmentStartTime": {},
  "nextAssignmentEndTime": {},
  "nextScheduledRunTime": {},
  "executedCalculationsCount": {},
  "iteration": {},
  "createTime": {},
  "updateTime": {},
  "status": {
    "scheduled": {
      "nextScheduleTime": {}
    },
    "cancelled": {
      "cancelledTime": {}
    },
    "calculating": {
      "exposureCalculation": "<string>"
    },
    "waiting": {
      "needDataUntilTime": {},
      "assignmentTable": "<string>",
      "factTable": "<string>",
      "dataDeliveredUntilTime": {}
    },
    "error": {
      "errorMessage": "<string>"
    }
  },
  "creator": "<string>",
  "updater": "<string>",
  "name": "<string>",
  "scheduleEndTime": {},
  "exposureTable": "<string>",
  "state": "STATE_UNSPECIFIED",
  "exposedEntitiesMetric": "<string>",
  "exposedEntitiesMetricSchedule": "<string>",
  "labels": [
    {}
  ],
  "activeRetrigger": "<string>",
  "displayName": "<string>",
  "owner": "<string>"
}

Get Started

Feature Flags

Metrics

Stats

Experiments

Surfaces

IAM

Connectors

Authorizations

Path Parameters

Body

Response