github.com/grafana/synthetic-monitoring-agent@v0.64.2/pkg/pb/synthetic_monitoring/checks.proto

// Copyright 2020 Grafana Labs
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

syntax = "proto3";
package synthetic_monitoring;

import "gogoproto/gogo.proto";

option go_package = "github.com/grafana/synthetic-monitoring-agent/pkg/pb/synthetic_monitoring";
option (gogoproto.enum_stringer_all) = false;
option (gogoproto.goproto_getters_all) = false;
option (gogoproto.goproto_sizecache_all) = false;
option (gogoproto.goproto_unkeyed_all) = false;
option (gogoproto.goproto_unrecognized_all) = false;
option (gogoproto.marshaler_all) = true;
option (gogoproto.sizer_all) = true;
option (gogoproto.unmarshaler_all) = true;

service Checks {
  // RegisterProbe causes this probe to be reported as online with
  // synthetic-monitoring-api.
  //
  // The probe is identified via an authentication token provided
  // through a different channel by synthetic-monitoring-api.
  rpc RegisterProbe(ProbeInfo) returns (RegisterProbeResult) {}

  // GetChanges returns a list of check operations, specifying
  // whether to add, update or delete checks.
  rpc GetChanges(ProbeState) returns (stream Changes) {}

  // Ping sends a ping to the server and receives an
  // acknowledgement back.
  rpc Ping(PingRequest) returns (PongResponse) {}
}

service AdHocChecks {
  // RegisterProbe causes this probe to be reported as available
  // with synthetic-monitoring-api.
  //
  // The probe is identified via an authentication token provided
  // through a different channel by synthetic-monitoring-api.
  rpc RegisterProbe(ProbeInfo) returns (RegisterProbeResult) {}

  // GetAdHocChecks returns a list of checks to be run immediately.
  rpc GetAdHocChecks(Void) returns (stream AdHocRequest) {}
}

// Void is an empty message used by RPC methods that don't take
// arguments.
message Void {}

// ProbeState message is sent by probes as the argument to GetChanges. It contains a list
// of the checks and tenants already known to the probe.
message ProbeState {
  repeated EntityRef checks = 1 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "checks"
  ];
  repeated EntityRef tenants = 2 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "tenants"
  ];
}

// EntityRef represents a reference to an entity (check, tenant) by it's ID and last modification time.
message EntityRef {
  int64 id = 1 [(gogoproto.jsontag) = "id"];
  double lastModified = 2 [(gogoproto.jsontag) = "lastModified"];
}

message ProbeInfo {
  string Version = 1 [(gogoproto.jsontag) = "version"]; // version of the probe
  string Commit = 2 [(gogoproto.jsontag) = "commit"]; // commit hash used to build the probe
  string Buildstamp = 3 [(gogoproto.jsontag) = "buildstamp"]; // timestamp when the probe was built
  bool supportsProtocolSecrets = 4 [(gogoproto.jsontag) = "supportsProtocolSecrets"]; // true when protocol secrets are supported in the Agent
}

// PingRequest is the message sent as argument of the Ping method.
message PingRequest {
  int64 Sequence = 1 [(gogoproto.jsontag) = "sequence"]; // sequence number
}

// PongResponse is the message received as response from the Ping method.
message PongResponse {
  int64 Sequence = 1 [(gogoproto.jsontag) = "sequence"]; // sequence number
}

// StatusCode represents the result of registering a probe with the API.
enum StatusCode {
  OK = 0;
  NOT_FOUND = 1;
  INVALID_ARGUMENT = 2;
  ALREADY_EXISTS = 3;
  INTERNAL_ERROR = 4;
  NOT_AUTHORIZED = 5;
}

// Status represents the result of registering a probe with the API,
// including both a code as well as textual message that can be
// presented to the user.
message Status {
  StatusCode code = 1;
  string message = 2;
}

// RegisterProbeResult is the message returned by the RegisterProbe
// method of the Checks service. It provides both the status of the
// operation and the probe's details after successful registration.
message RegisterProbeResult {
  Probe probe = 1 [(gogoproto.nullable) = false];
  Status status = 2 [(gogoproto.nullable) = false];
}

// Probe represents a probe.
message Probe {
  message Capabilities {
    bool disableScriptedChecks = 1 [(gogoproto.jsontag) = "disableScriptedChecks"]; // probe should not run scripted checks
    bool disableBrowserChecks = 2 [(gogoproto.jsontag) = "disableBrowserChecks"]; // probe should not run browser checks
    bool enableProtocolSecrets = 3 [(gogoproto.jsontag) = "enableProtocolSecrets"]; // true when protocol secrets are enabled in the API
  }

  int64 id = 1 [(gogoproto.jsontag) = "id"]; // ID of the probe, assigned by the API
  int64 tenantId = 2 [(gogoproto.jsontag) = "tenantId"]; // ID of the synthetic-monitoring tenant this probe belongs to
  string name = 3 [(gogoproto.jsontag) = "name"]; // name of the probe
  float latitude = 4 [(gogoproto.jsontag) = "latitude"]; // latitude of the probe
  float longitude = 5 [(gogoproto.jsontag) = "longitude"]; // longitude of the probe
  repeated Label labels = 6 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "labels"
  ]; // probe-specific labels applied to all metrics and events
  string region = 7 [(gogoproto.jsontag) = "region"]; // region of the probe, such as AMER, EMEA, APAC
  bool public = 8 [(gogoproto.jsontag) = "public"]; // whether the probe is private or shared with all users
  bool online = 9 [(gogoproto.jsontag) = "online"]; // whether the probe is currently online
  double onlineChange = 10 [(gogoproto.jsontag) = "onlineChange"]; // time probe started or stopped being online
  string version = 11 [(gogoproto.jsontag) = "version"]; // version of the probe
  string commit = 12 [(gogoproto.jsontag) = "commit"]; // commit hash used to build the probe
  string buildstamp = 13 [(gogoproto.jsontag) = "buildstamp"]; // timestamp when the probe was built
  bool deprecated = 14 [(gogoproto.jsontag) = "deprecated"]; // whether the probe has been deprecated
  double created = 100 [(gogoproto.jsontag) = "created"]; // time the probe was created
  double modified = 101 [(gogoproto.jsontag) = "modified"]; // last time modified
  Capabilities capabilities = 102 [(gogoproto.jsontag) = "capabilities"]; // probe feature enablements
}

service Tenants {
  // GetTenant returns the details of the specified tenant
  rpc GetTenant(TenantInfo) returns (Tenant) {}
}

// TenantInfo identifies the tenant for which information is being
// requeted via the GetTenant method of the Tenants service.
message TenantInfo {
  int64 id = 1;
}

// TenantStatus represents the status associated to particular tenant.
enum TenantStatus {
  ACTIVE = 0;
  DISABLED = 1;
}

// LabelMode controls how user-defined labels are written to metrics and logs.
//
// State machine:
//   PREFIXED → DUAL_WRITE   irreversible; additive (existing queries still work)
//   DUAL_WRITE ↔ UNPREFIXED reversible; finalize when all policies are migrated
enum LabelMode {
  LABEL_MODE_PREFIXED   = 0;  // default — all user labels get the label_ prefix
  LABEL_MODE_DUAL_WRITE = 1;  // writes both label_foo and foo; entry is irreversible from PREFIXED
  LABEL_MODE_UNPREFIXED = 2;  // writes foo only; reserved names silently ignored; reversible to DUAL_WRITE
}

// TenantLimits specifies the limits for a tenant.
message TenantLimits {
  int64 maxChecks = 1 [(gogoproto.jsontag) = "maxChecks"];
  int64 maxScriptedChecks = 2 [(gogoproto.jsontag) = "maxScriptedChecks"];
  int64 maxMetricLabels = 3 [(gogoproto.jsontag) = "maxMetricLabels"];
  int64 maxLogLabels = 4 [(gogoproto.jsontag) = "maxLogLabels"];
  int64 maxBrowserChecks = 5 [(gogoproto.jsontag) = "maxBrowserChecks"];
}

// SecretStore contains details for accessing the Grafana secret store
message SecretStore {
  string url = 1 [(gogoproto.jsontag) = "url"]; // secret service URL
  string token = 2 [(gogoproto.jsontag) = "token"]; // secret service token
  double expiry = 3 [(gogoproto.jsontag) = "expiry"]; // unix timestamp when the secret store token expires
}

// Tenant represents a user of synthetic-monitoring.
message Tenant {
  int64 id = 1 [(gogoproto.jsontag) = "id"]; // unique ID
  int64 orgId = 2 [(gogoproto.jsontag) = "orgId"]; // grafana.com orgId
  RemoteInfo metricsRemote = 3 [(gogoproto.jsontag) = "metricsRemote"]; // target to send metrics to
  RemoteInfo eventsRemote = 4 [(gogoproto.jsontag) = "eventsRemote"]; // target to send events to
  int64 stackId = 5 [(gogoproto.jsontag) = "stackId"]; // grafana.com stackId
  TenantStatus status = 6 [(gogoproto.jsontag) = "status"]; // tenant status
  string reason = 7 [(gogoproto.jsontag) = "reason"]; // reason provided for the status
  TenantLimits limits = 8 [(gogoproto.jsontag) = "limits"]; // check and label limits

  repeated string costAttributionLabels = 9 [(gogoproto.jsontag) = "costAttributionLabels"]; // list of cost attribution label keys that must be set on checks

  LabelMode label_mode = 10 [(gogoproto.jsontag) = "labelMode"]; // controls how user-defined labels are written to metrics and logs

  double created = 100 [(gogoproto.jsontag) = "created"]; // time the check was created
  double modified = 101 [(gogoproto.jsontag) = "modified"]; // last time modified
  SecretStore secretStore = 102 [(gogoproto.jsontag) = "secretStore"]; // secret store details
}

// RemoteInfo represents an instance of the Prometheus remote write
// service to send metrics or events to.
message RemoteInfo {
  string name = 1 [(gogoproto.jsontag) = "name"]; // instance name
  string url = 2 [(gogoproto.jsontag) = "url"]; // instance URL
  string username = 3 [(gogoproto.jsontag) = "username"]; // username (instanceId)
  string password = 4 [(gogoproto.jsontag) = "password"]; // password (publisher API key)
}

// CheckOperation represents an operation to be performed on a
// particular check.
enum CheckOperation {
  CHECK_ADD = 0;
  CHECK_UPDATE = 1;
  CHECK_DELETE = 2;
}

// CheckChange represents one change operation for a given check.
message CheckChange {
  CheckOperation operation = 1;
  Check check = 2 [(gogoproto.nullable) = false];
}

// Changes represents a series of changes to be applied to the workloads
// running on the probe.
//
// When a probe connects, it will get a sequence of changes describing
// all the checks associated to that probe. After the initial batch, it
// will continue getting changes as they happen.
//
// When a tenant's credentials change, this message will contain the new
// information for that tenant.
message Changes {
  repeated CheckChange checks = 1 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "checks"
  ];
  repeated Tenant tenants = 2 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "tenants"
  ];

  // This field is used to signal that the list of changes should be interpreted as a diff
  // against the existing changes in the probe. For backwards compatibility, this will be
  // false if the probe didn't send a list of known changes.
  bool isDeltaFirstBatch = 3 [(gogoproto.jsontag) = "isDeltaFirstBatch"];
}

message AdHocRequest {
  AdHocCheck adHocCheck = 1 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "adHocCheck"
  ];
  Tenant tenant = 2 [
    (gogoproto.nullable) = true,
    (gogoproto.jsontag) = "tenant"
  ];
}

// Label represents a single label in synthetic monitoring. These are
// applied to the resulting metrics and logs.
message Label {
  string name = 1 [(gogoproto.jsontag) = "name"];
  string value = 2 [(gogoproto.jsontag) = "value"];
}

// CostAttributionLabel is similar to a label, but specifically for transmitting costAttributionLabels.
// The initial use case for CAL's is such that they are effectively the same as labels.
// Over time that will change, so we should treat them as separate messages to ensure they do not become tightly coupled.
message CostAttributionLabel {
  string name = 1 [(gogoproto.jsontag) = "name"];
  string value = 2 [(gogoproto.jsontag) = "value"];
}

// Check represents a check.
//
// The "settings" field defines the type of check.
message Check {
  int64 id = 1 [(gogoproto.jsontag) = "id"]; // unique ID
  int64 tenantId = 2 [(gogoproto.jsontag) = "tenantId"]; // synthetic-monitoring tenant
  int64 frequency = 3 [(gogoproto.jsontag) = "frequency"]; // every X milliseconds
  int64 offset = 4 [(gogoproto.jsontag) = "offset"]; // ??? REMOVE???? ??? why user configured?
  int64 timeout = 5 [(gogoproto.jsontag) = "timeout"]; // maximum time before aborting
  bool enabled = 6 [(gogoproto.jsontag) = "enabled"]; // user enable/disable
  repeated Label labels = 7 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "labels"
  ]; // custom labels applied to all metrics and events (ie: production)
  CheckSettings settings = 8 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "settings"
  ]; // check-specific settings
  repeated int64 probes = 9 [(gogoproto.jsontag) = "probes"]; // list of probes where this check should run
  string target = 10 [(gogoproto.jsontag) = "target"]; // endpoint that this check is targeting
  string job = 11 [(gogoproto.jsontag) = "job"]; // name of job this check belongs to
  bool basicMetricsOnly = 12 [(gogoproto.jsontag) = "basicMetricsOnly"]; // include only basic metrics
  string alertSensitivity = 13 [(gogoproto.jsontag) = "alertSensitivity"];
  Channels channels = 14 [(gogoproto.jsontag) = "channels"]; // channels this check is assigned to
  double created = 100 [(gogoproto.jsontag) = "created"]; // time the check was created
  double modified = 101 [(gogoproto.jsontag) = "modified"]; // last time modified
}

message AdHocCheck {
  string id = 1 [(gogoproto.jsontag) = "id"]; // unique ID
  int64 tenantId = 2 [(gogoproto.jsontag) = "tenantId"]; // synthetic-monitoring tenant
  int64 timeout = 3 [(gogoproto.jsontag) = "timeout"]; // maximum time before aborting
  CheckSettings settings = 4 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "settings"
  ]; // check-specific settings
  repeated int64 probes = 5 [(gogoproto.jsontag) = "probes"]; // list of probes where this check should run
  string target = 6 [(gogoproto.jsontag) = "target"]; // endpoint that this check is targeting
  Channels channels = 7 [(gogoproto.jsontag) = "channels"]; // channels this check is assigned to
}

// CheckSettings provides the settings for exactly one type of check.
message CheckSettings {
  option (gogoproto.onlyone) = true;
  PingSettings ping = 1 [(gogoproto.jsontag) = "ping,omitempty"];
  HttpSettings http = 2 [(gogoproto.jsontag) = "http,omitempty"];
  DnsSettings dns = 3 [(gogoproto.jsontag) = "dns,omitempty"];
  TcpSettings tcp = 4 [(gogoproto.jsontag) = "tcp,omitempty"];
  TracerouteSettings traceroute = 5 [(gogoproto.jsontag) = "traceroute,omitempty"];
  ScriptedSettings scripted = 6 [(gogoproto.jsontag) = "scripted,omitempty"]; // experimental
  MultiHttpSettings multihttp = 7 [(gogoproto.jsontag) = "multihttp,omitempty"]; // experimental
  GrpcSettings grpc = 8 [(gogoproto.jsontag) = "grpc,omitempty"]; // experimental
  BrowserSettings browser = 9 [(gogoproto.jsontag) = "browser,omitempty"]; // experimental
}

// PingSettings provides the settings for a ping check.
message PingSettings {
  IpVersion ipVersion = 1 [(gogoproto.jsontag) = "ipVersion"]; // IP version used in the IP layer
  string sourceIpAddress = 2 [(gogoproto.jsontag) = "sourceIpAddress,omitempty"]; // source IP address for the packets
  int64 payloadSize = 3 [(gogoproto.jsontag) = "payloadSize,omitempty"]; // size of the ICMP packet's data portion
  bool dontFragment = 4 [(gogoproto.jsontag) = "dontFragment"]; // set the IP don't fragment option

  // custom settings not present in blackbox-exporter

  int64 packetCount = 900 [(gogoproto.jsontag) = "packetCount"]; // number of ping packets to send
}

// HttpMethod represents the HTTP method used when making HTTP requests.
enum HttpMethod {
  GET = 0;
  CONNECT = 1;
  DELETE = 2;
  HEAD = 3;
  OPTIONS = 4;
  POST = 5;
  PUT = 6;
  TRACE = 7;
  PATCH = 8;
}

// HttpSettings provides the settings for a HTTP check.
message HttpSettings {
  IpVersion ipVersion = 1 [(gogoproto.jsontag) = "ipVersion"];
  HttpMethod method = 2 [(gogoproto.jsontag) = "method"];
  repeated string headers = 3 [(gogoproto.jsontag) = "headers,omitempty"];
  string body = 4 [(gogoproto.jsontag) = "body,omitempty"];
  bool noFollowRedirects = 5 [(gogoproto.jsontag) = "noFollowRedirects"];

  // client config

  TLSConfig tlsConfig = 100 [(gogoproto.jsontag) = "tlsConfig,omitempty"];
  BasicAuth basicAuth = 101 [(gogoproto.jsontag) = "basicAuth,omitempty"];
  string bearerToken = 102 [(gogoproto.jsontag) = "bearerToken,omitempty"];
  string proxyURL = 103 [(gogoproto.jsontag) = "proxyURL,omitempty"];
  OAuth2Config oauth2Config = 104 [(gogoproto.jsontag) = "oauth2Config,omitempty"];
  repeated string proxyConnectHeaders = 105 [(gogoproto.jsontag) = "proxyConnectHeaders,omitempty"];

  // validations

  bool failIfSSL = 200 [(gogoproto.jsontag) = "failIfSSL"];
  bool failIfNotSSL = 201 [(gogoproto.jsontag) = "failIfNotSSL"];
  repeated int32 validStatusCodes = 202 [(gogoproto.jsontag) = "validStatusCodes,omitempty"];
  repeated string validHTTPVersions = 203 [(gogoproto.jsontag) = "validHTTPVersions,omitempty"];
  repeated string failIfBodyMatchesRegexp = 204 [(gogoproto.jsontag) = "failIfBodyMatchesRegexp,omitempty"];
  repeated string failIfBodyNotMatchesRegexp = 205 [(gogoproto.jsontag) = "failIfBodyNotMatchesRegexp,omitempty"];
  repeated HeaderMatch failIfHeaderMatchesRegexp = 206 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "failIfHeaderMatchesRegexp,omitempty"
  ];
  repeated HeaderMatch failIfHeaderNotMatchesRegexp = 207 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "failIfHeaderNotMatchesRegexp,omitempty"
  ];
  CompressionAlgorithm compression = 208 [(gogoproto.jsontag) = "compression,omitempty"];

  // custom settings not present in blackbox-exporter

  string cacheBustingQueryParamName = 900 [(gogoproto.jsontag) = "cacheBustingQueryParamName,omitempty"];
  bool secretManagerEnabled = 901 [(gogoproto.jsontag) = "secretManagerEnabled,omitempty"];
}

// Configuration for two-legged OAuth2 (client_credentials grant type).
message OAuth2Config {
  string clientId = 1 [(gogoproto.jsontag) = "clientId"]; // (Required) client identifier
  string clientSecret = 2 [(gogoproto.jsontag) = "clientSecret"]; // (Required) client secret
  string tokenURL = 3 [(gogoproto.jsontag) = "tokenURL"]; // (Required) URL for the token endpoint
  repeated string scopes = 4 [(gogoproto.jsontag) = "scopes,omitempty"]; // Service-specific list of scopes
  repeated Label endpointParams = 5 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "endpointParams,omitempty"
  ]; // Extra request parameters to use with token endpoint
  TLSConfig tlsConfig = 6 [(gogoproto.jsontag) = "tlsConfig,omitempty"];
  string proxyURL = 7 [(gogoproto.jsontag) = "proxyURL,omitempty"];
}

// HeaderMatch represents a single header that must match in order for
// the check to be considered successful.
message HeaderMatch {
  string header = 1 [(gogoproto.jsontag) = "header,omitempty"]; // the header to match
  string regexp = 2 [(gogoproto.jsontag) = "regexp,omitempty"]; // a regular expression to match against the header's value
  bool allowMissing = 3 [(gogoproto.jsontag) = "allowMissing,omitempty"]; // consider the match successful if the header is absent
}

// DnsRecordType represents the DNS record types to be queried in DNS
// checks.
enum DnsRecordType {
  ANY = 0;
  A = 1;
  AAAA = 2;
  CNAME = 3;
  MX = 4;
  NS = 5;
  PTR = 6;
  SOA = 7;
  SRV = 8;
  TXT = 9;
}

// DnsProtocol represents the IP protocol to use for DNS queries.
enum DnsProtocol {
  TCP = 0;
  UDP = 1;
}

// DNSRRValidator represents the DNS resource record validations.
message DNSRRValidator {
  repeated string failIfMatchesRegexp = 1 [(gogoproto.jsontag) = "failIfMatchesRegexp,omitempty"];
  repeated string failIfNotMatchesRegexp = 2 [(gogoproto.jsontag) = "failIfNotMatchesRegexp,omitempty"];
}

// DnsSettings provides the settings for a DNS check.
//
// The way blackbox-exporter works, a DNS check tests a _server_, so the
// _target_ of the check is a server address, and the check itself
// contains the record to check.
//
// "ipVersion" is the IP version to use in the IP layer.
message DnsSettings {
  IpVersion ipVersion = 1 [(gogoproto.jsontag) = "ipVersion"];
  string sourceIpAddress = 2 [(gogoproto.jsontag) = "sourceIpAddress,omitempty"];
  string server = 3 [(gogoproto.jsontag) = "server"];
  int32 port = 4 [(gogoproto.jsontag) = "port"];
  DnsRecordType recordType = 5 [(gogoproto.jsontag) = "recordType"];
  DnsProtocol protocol = 6 [(gogoproto.jsontag) = "protocol"];

  // validations

  repeated string validRCodes = 200 [(gogoproto.jsontag) = "validRCodes,omitempty"];
  DNSRRValidator validateAnswer = 201 [(gogoproto.jsontag) = "validateAnswerRRS,omitempty"];
  DNSRRValidator validateAuthority = 202 [(gogoproto.jsontag) = "validateAuthorityRRS,omitempty"];
  DNSRRValidator validateAdditional = 203 [(gogoproto.jsontag) = "validateAdditionalRRS,omitempty"];
}

// TcpSettings provides the settings for a TCP check.
//
// "ipVersion" is the IP version to use in the IP layer.
message TcpSettings {
  IpVersion ipVersion = 1 [(gogoproto.jsontag) = "ipVersion"];
  string sourceIpAddress = 2 [(gogoproto.jsontag) = "sourceIpAddress,omitempty"];
  bool tls = 3 [(gogoproto.jsontag) = "tls,omitempty"];
  TLSConfig tlsConfig = 4 [(gogoproto.jsontag) = "tlsConfig,omitempty"];
  repeated TCPQueryResponse queryResponse = 5 [
    (gogoproto.jsontag) = "queryResponse,omitempty",
    (gogoproto.nullable) = false
  ];
}

// TCPQueryResponse represents a single step in a sequence of
// send/expect pairs to be used when connecting to a generic TCP
// service.
message TCPQueryResponse {
  bytes send = 1 [(gogoproto.jsontag) = "send"];
  bytes expect = 2 [(gogoproto.jsontag) = "expect"];
  bool startTLS = 3 [(gogoproto.jsontag) = "startTLS,omitempty"];
}

// IpVersion represents the version of the IP protocol to be used in
// checks.
enum IpVersion {
  Any = 0; // use IPv6 if supported and fall back to IPv4 otherwise
  V4 = 1; // use IPv4 only
  V6 = 2; // use IPv6 only
}

// CompressionAlgorithm represents the compression algorithm to use.
enum CompressionAlgorithm {
  none = 0; // no compression algorithm
  identity = 1; // no compression, passthru
  gzip = 2; // gzip
  br = 3; // br, brotli
  deflate = 4; // deflate
}

// TLSConfig represents the TLS data to be used when establishing a
// secure connection in the protocols that support it.
message TLSConfig {
  bool insecureSkipVerify = 1 [(gogoproto.jsontag) = "insecureSkipVerify,omitempty"];
  bytes CACert = 2 [(gogoproto.jsontag) = "caCert,omitempty"];
  bytes clientCert = 3 [(gogoproto.jsontag) = "clientCert,omitempty"];
  bytes clientKey = 4 [(gogoproto.jsontag) = "clientKey,omitempty"];
  string serverName = 5 [(gogoproto.jsontag) = "serverName,omitempty"];
}

// BasicAuth represents the basic authentication credentials to be used
// when talking to HTTP servers.
message BasicAuth {
  string username = 1 [(gogoproto.jsontag) = "username,omitempty"];
  string password = 2 [(gogoproto.jsontag) = "password,omitempty"];
}

message TracerouteSettings {
  int64 maxHops = 1 [(gogoproto.jsontag) = "maxHops"]; // Maximimum hops to make in a traceroute before exiting
  int64 maxUnknownHops = 2 [(gogoproto.jsontag) = "maxUnknownHops"]; // Maximum hops probe that give no response before giving up
  bool ptrLookup = 3 [(gogoproto.jsontag) = "ptrLookup"]; // Include reverse DNS lookup
  int64 hopTimeout = 4 [(gogoproto.jsontag) = "hopTimeout"]; // Timeout for individual hop pings
}

message ScriptedSettings {
  bytes script = 1 [(gogoproto.jsontag) = "script"];
}

// MultiHttpSettings represents the settings for the MultiHttp check type.
message MultiHttpSettings {
  repeated MultiHttpEntry entries = 1 [(gogoproto.jsontag) = "entries"]; // One or more entries in the MultiHttp check
  bool logResponses = 2 [(gogoproto.jsontag) = "logResponseBodies,omitempty"]; // Whether to log the response bodies in the output.
}

// MultiHttpEntry represents a single entry in a MultiHttp check.
message MultiHttpEntry {
  MultiHttpEntryRequest request = 1 [(gogoproto.jsontag) = "request,omitempty"]; // The request parameters.
  repeated MultiHttpEntryAssertion assertions = 2 [(gogoproto.jsontag) = "checks,omitempty"]; // Zero or more assertions to be made on the response.
  repeated MultiHttpEntryVariable variables = 3 [(gogoproto.jsontag) = "variables,omitempty"]; // Zero or more variables to be used in the request.
}

// HttpHeader represents a single HTTP header key-value pair.
message HttpHeader {
  string name = 1 [(gogoproto.jsontag) = "name"]; // The name.
  string value = 2 [(gogoproto.jsontag) = "value"]; // The value.
}

// QueryField represents a single query field key-value pair.
message QueryField {
  string name = 1 [(gogoproto.jsontag) = "name"]; // The name.
  string value = 2 [(gogoproto.jsontag) = "value"]; // The value.
}

// MultiHttpEntryRequest contains the settings for a single request in a MultiHttp check.
message MultiHttpEntryRequest {
  HttpMethod method = 1 [(gogoproto.jsontag) = "method"]; // The HTTP method to use.
  string url = 2 [(gogoproto.jsontag) = "url"]; // The URL for the request.
  repeated HttpHeader headers = 3 [(gogoproto.jsontag) = "headers,omitempty"]; // Zero or more headers to be sent with the request.
  repeated QueryField queryFields = 4 [(gogoproto.jsontag) = "queryFields,omitempty"]; // Zero or more query fields to be sent with the request.
  HttpRequestBody body = 5 [(gogoproto.jsontag) = "body,omitempty"]; // The request body.
  // TODO(mem): we could add the HTTP version here, but that's an assertion,
  // there doesn't seem to be a way in k6 to specify which protocol to use
  // (even if the underlying Go library supports it).
}

// HttpRequestBody represents the body of an HTTP request.
message HttpRequestBody {
  string contentType = 1 [(gogoproto.jsontag) = "contentType"]; // The content-type of the body.
  string contentEncoding = 2 [(gogoproto.jsontag) = "contentEncoding,omitempty"]; // The content-encoding of the body.
  bytes payload = 3 [(gogoproto.jsontag) = "payload"]; // The payload of the body.
}

// MultiHttpEntryAssertionType represents the type of assertion to be made.
enum MultiHttpEntryAssertionType {
  TEXT = 0;
  JSON_PATH_VALUE = 1;
  JSON_PATH_ASSERTION = 2;
  REGEX_ASSERTION = 3;
  option (gogoproto.goproto_enum_stringer) = false;
}

// MultiHttpEntryAssertionSubjectVariant represents the subject of the assertion.
enum MultiHttpEntryAssertionSubjectVariant {
  DEFAULT_SUBJECT = 0;
  RESPONSE_HEADERS = 1;
  HTTP_STATUS_CODE = 2;
  RESPONSE_BODY = 3;
  option (gogoproto.goproto_enum_stringer) = false;
}

// MultiHttpEntryAssertionConditionVariant represents the condition between the assertion's expression and value.
enum MultiHttpEntryAssertionConditionVariant {
  DEFAULT_CONDITION = 0;
  NOT_CONTAINS = 1;
  EQUALS = 2;
  STARTS_WITH = 3;
  ENDS_WITH = 4;
  TYPE_OF = 5;
  CONTAINS = 6;
  option (gogoproto.goproto_enum_stringer) = false;
}

// MultiHttpEntryAssertion represents a single assertion to be made on the response.
//
// The `value` field specifies the _value_ that the subject and the condition
// should meet, e.g. if the subject is body and the condition is contains,
// value specifies the substring that should be found in the body.
//
// For the JSON_PATH_VALUE type, `expression` specifies the JSON path to match against `value`.
//
// For the JSON_PATH_ASSERTION type, `expression` specifies the JSON path to assert.
//
// For the TEXT type, if the subject is `RESPONSE_HEADERS`, `expression`
// specifies which specific header should be used as the subject of the
// operation. Headers are case-insensitive (RFC 7230, section 3.2,
// https://datatracker.ietf.org/doc/html/rfc7230#section-3.2).
message MultiHttpEntryAssertion {
  MultiHttpEntryAssertionType type = 1 [(gogoproto.jsontag) = "type"];
  MultiHttpEntryAssertionSubjectVariant subject = 2 [(gogoproto.jsontag) = "subject,omitempty"];
  MultiHttpEntryAssertionConditionVariant condition = 3 [(gogoproto.jsontag) = "condition,omitempty"];
  string expression = 4 [(gogoproto.jsontag) = "expression,omitempty"];
  string value = 5 [(gogoproto.jsontag) = "value,omitempty"];
}

// MultiHttpEntryVariableType represents the type of expression used to populate the variable.
enum MultiHttpEntryVariableType {
  JSON_PATH = 0;
  REGEX = 1;
  CSS_SELECTOR = 2;
  option (gogoproto.goproto_enum_stringer) = false;
}

// MultiHttpEntryVariable represents a single variable to be used in the request.
message MultiHttpEntryVariable {
  MultiHttpEntryVariableType type = 1 [(gogoproto.jsontag) = "type"];
  string name = 2 [(gogoproto.jsontag) = "name,omitempty"];
  string expression = 3 [(gogoproto.jsontag) = "expression,omitempty"];
  string attribute = 4 [(gogoproto.jsontag) = "attribute,omitempty"];
}

// GrpcSettings provides the settings for a gRPC check.
message GrpcSettings {
  IpVersion ipVersion = 1 [(gogoproto.jsontag) = "ipVersion"];
  string service = 2 [(gogoproto.jsontag) = "service,omitempty"];
  bool tls = 3 [(gogoproto.jsontag) = "tls,omitempty"];
  TLSConfig tlsConfig = 4 [(gogoproto.jsontag) = "tlsConfig,omitempty"];
}

// BrowserSettings provides the settings for a browser check.
message BrowserSettings {
  bytes script = 1 [(gogoproto.jsontag) = "script"];
}

// Channels represents the channels a check is assigned to.
message Channels {
  K6Channel k6 = 1 [(gogoproto.jsontag) = "k6"];
}

// K6Channel represents the k6 channel a check is assigned to.
message K6Channel {
  string id = 1 [(gogoproto.jsontag) = "id"];
  string manifest = 2 [(gogoproto.jsontag) = "manifest"];
}

service Telemetry {
  // PushTelemetry pushes telemetry data for all the tenants that are running
  // checks in the agent which belong to the same region.
  rpc PushTelemetry(RegionTelemetry) returns (PushTelemetryResponse) {}
}

// CheckClass represents the supported check classes.
enum CheckClass {
  PROTOCOL = 0;
  SCRIPTED = 1;
  BROWSER = 2;
}

// RegionTelemetry represents the telemetry data for a specific region.
// Groups the telemetry data for all the tenants that have checks being
// executed in the agent and belong to the same region.
message RegionTelemetry {
  string instance = 1 [(gogoproto.jsontag) = "instance"]; // Identifies the agent instance
  int32 regionId = 2 [(gogoproto.jsontag) = "regionId"];
  repeated TenantTelemetry telemetry = 3 [(gogoproto.jsontag) = "telemetry"];
}

// TenantTelemetry represents the telemetry data for a specific tenant.
message TenantTelemetry {
  int64 tenantId = 1 [(gogoproto.jsontag) = "tenantId"]; // Local tenant ID
  repeated CheckClassTelemetry telemetry = 2 [(gogoproto.jsontag) = "telemetry"];
}

// CheckClassTelemetry represents the telemetry data for a specific check class.
message CheckClassTelemetry {
  CheckClass checkClass = 1 [(gogoproto.jsontag) = "checkClass"];
  int32 executions = 2 [(gogoproto.jsontag) = "executions"];
  float duration = 3 [(gogoproto.jsontag) = "duration"];
  int32 sampledExecutions = 4 [(gogoproto.jsontag) = "sampledExecutions"];
  repeated CostAttributionLabel costAttributionLabels = 5 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "costAttributionLabels"
  ];
}

// PushTelemetryResponse represents a response for a push telemetry rpc call.
message PushTelemetryResponse {
  Status status = 1 [(gogoproto.jsontag) = "status"];
}

// K6 service represents a service that allows the probes to report information
// on supported k6 versions.
service K6 {
  // RegisterK6Version registers the k6 versions supported by the probe.
  rpc RegisterK6Version(RegisterK6VersionRequest) returns (RegisterK6VersionResponse) {}
}

// K6Version represents a specific k6 version supported by a probe.
message K6Version {
  string version = 1 [(gogoproto.jsontag) = "version"]; // semantic version 2.0.0 string (e.g. 0.50.0)
}

message RegisterK6VersionRequest {
  repeated K6Version versions = 1 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "versions"
  ];
}

message RegisterK6VersionResponse {
  Status status = 1 [
    (gogoproto.nullable) = false,
    (gogoproto.jsontag) = "status"
  ];
}