configv1UpdateLogControlConfigResponse

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://raw.githubusercontent.com/api-evangelist/chronosphere/main/json-schema/chronosphere-configv1-update-log-control-config-response-schema.json",
  "title": "configv1UpdateLogControlConfigResponse",
  "x-generated": "2026-10-03",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/chronosphere-logcontrolconfig-api-openapi.yml#/components/schemas/configv1UpdateLogControlConfigResponse",
  "properties": {
    "log_control_config": {
      "$ref": "#/$defs/configv1LogControlConfig"
    }
  },
  "type": "object",
  "$defs": {
    "EmitMetricsCounter": {
      "properties": {
        "value": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogFieldPath"
            }
          ],
          "description": "Optional. Specifies the name of the log field whose value you want to use as\nthe metric value. If unset, the counter increments by one."
        }
      },
      "type": "object"
    },
    "EmitMetricsGauge": {
      "properties": {
        "aggregation_type": {
          "allOf": [
            {
              "$ref": "#/$defs/GaugeAggregationType"
            }
          ],
          "description": "The aggregation type to use for the gauge. Must be one of the following\nvalues:"
        },
        "value": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogFieldPath"
            }
          ],
          "description": "The name of the log field whose value you want to use as the metric value."
        }
      },
      "required": [
        "value"
      ],
      "type": "object"
    },
    "EmitMetricsHistogram": {
      "properties": {
        "value": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogFieldPath"
            }
          ],
          "description": "The name of the log field whose value you want to use as the metric value."
        }
      },
      "required": [
        "value"
      ],
      "type": "object"
    },
    "EmitMetricsMetricMode": {
      "enum": [
        "COUNTER",
        "GAUGE",
        "HISTOGRAM"
      ],
      "type": "string"
    },
    "GaugeAggregationType": {
      "enum": [
        "LAST",
        "MIN",
        "MAX"
      ],
      "type": "string"
    },
    "LogControlRuleDropField": {
      "description": "DropField is the configuration for a drop field action.",
      "properties": {
        "field_regex": {
          "description": "Defines the the regular expression that determines which fields to drop.",
          "type": "string"
        },
        "parent_path": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogFieldPath"
            }
          ],
          "description": "Optional. Specifies the level of depth in the log to apply the regular\nexpression to. For example, if you want to apply the regular expression to\nfields under `httpRequest`, such as `httpRequest.status`, enter `httpRequest`\nin the `parent_path` field. If empty, the fields to drop are at the root level\nof the log."
        }
      },
      "required": [
        "field_regex"
      ],
      "type": "object"
    },
    "LogControlRuleEmitMetrics": {
      "description": "EmitMetrics is the configuration for emit metrics action.",
      "properties": {
        "counter": {
          "allOf": [
            {
              "$ref": "#/$defs/EmitMetricsCounter"
            }
          ],
          "description": "Generates a metric that counts the number of times a certain event has\noccurred."
        },
        "drop_log": {
          "description": "Optional. If `true`, drops the entire log after emitting the defined metric.",
          "type": "boolean"
        },
        "gauge": {
          "allOf": [
            {
              "$ref": "#/$defs/EmitMetricsGauge"
            }
          ],
          "description": "Generates a metric that tracks a value, which changes over time. Choose `LAST`\n(most recent), `MIN` (minimum value), or `MAX` (maximum value) to define which\nvalue to use."
        },
        "histogram": {
          "allOf": [
            {
              "$ref": "#/$defs/EmitMetricsHistogram"
            }
          ],
          "description": "Generates a metric that tracks the distribution of values across data\ngroupings with exponentially increasing size."
        },
        "labels": {
          "description": "The labels to emit with the metric, specified as key/value pairs. The\ngenerated label is a valid Prometheus label name, mapped to a log key.",
          "items": {
            "$ref": "#/$defs/LogControlRuleEmitMetricsLabel"
          },
          "type": "array"
        },
        "mode": {
          "allOf": [
            {
              "$ref": "#/$defs/EmitMetricsMetricMode"
            }
          ],
          "description": "Indicates the mode of the generated metric. Must be one of the following\nvalues:"
        },
        "name": {
          "description": "A unique name for the generated metric. This name must conform to Prometheus\nnaming conventions.",
          "type": "string"
        }
      },
      "required": [
        "mode",
        "name"
      ],
      "type": "object"
    },
    "LogControlRuleEmitMetricsLabel": {
      "properties": {
        "key": {
          "type": "string"
        },
        "value": {
          "$ref": "#/$defs/configv1LogFieldPath"
        }
      },
      "type": "object"
    },
    "LogControlRuleParseField": {
      "description": "ParseField is the configuration for a parse field action.",
      "properties": {
        "destination": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogFieldPath"
            }
          ],
          "description": "The destination field where parsed structured data will be written.\nIf the key already exists, the value will be overwritten.\nIf unset, the log will be updated at the root level and any conflicting \nkeys will be overwritten."
        },
        "parser": {
          "allOf": [
            {
              "$ref": "#/$defs/LogIngestConfigLogParser"
            }
          ],
          "description": "The parser to apply to the source field."
        },
        "source": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogFieldPath"
            }
          ],
          "description": "The source field to parse."
        }
      },
      "type": "object"
    },
    "LogControlRuleReplaceField": {
      "description": "ReplaceField is the configuration for a replace field action.",
      "properties": {
        "field": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogFieldPath"
            }
          ],
          "description": "Specifies the field inside the log data to apply the rule to."
        },
        "mapped_value": {
          "allOf": [
            {
              "$ref": "#/$defs/ReplaceFieldMappedValue"
            }
          ],
          "description": "Defines the configuration for the mapped value replacement mode."
        },
        "replace_all": {
          "description": "Determines whether to replace all matches or just the first match.",
          "type": "boolean"
        },
        "replace_mode": {
          "allOf": [
            {
              "$ref": "#/$defs/ReplaceFieldReplaceMode"
            }
          ],
          "description": "Defines the replacement mode to use in the replace rule. Must be one of the\nfollowing values:"
        },
        "replace_regex": {
          "description": "Defines the the regular expression that determines which part of the field to\nreplace.",
          "type": "string"
        },
        "static_value": {
          "allOf": [
            {
              "$ref": "#/$defs/ReplaceFieldStaticValue"
            }
          ],
          "description": "Defines the configuration for the fixed value replacement mode."
        }
      },
      "required": [
        "field",
        "replace_mode",
        "replace_regex"
      ],
      "type": "object"
    },
    "LogControlRuleSample": {
      "description": "Sample is the configuration for the sample logs action.",
      "properties": {
        "rate": {
          "description": "Percentage of matching logs to keep. Must be in the range `[0, 1]`, where `1`\nis equal to 100% of logs. For example, to keep 25% of logs, enter `0.25` as\nthe `rate`.",
          "format": "double",
          "type": "number"
        }
      },
      "required": [
        "rate"
      ],
      "type": "object"
    },
    "LogIngestConfigLogParser": {
      "properties": {
        "grok_parser": {
          "$ref": "#/$defs/LogParserGrokParser"
        },
        "key_value_parser": {
          "$ref": "#/$defs/LogParserKeyValueParser"
        },
        "parser_type": {
          "allOf": [
            {
              "$ref": "#/$defs/LogParserParserType"
            }
          ],
          "description": "The type of parser to use."
        },
        "regex_parser": {
          "allOf": [
            {
              "$ref": "#/$defs/LogParserRegexParser"
            }
          ],
          "description": "This object contains settings relevant to `REGEX` parsers."
        }
      },
      "type": "object"
    },
    "LogParserGrokParser": {
      "properties": {
        "pattern": {
          "description": "The grok pattern to apply. Named capture groups become named fields in \nthe extracted log.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "LogParserKeyValueParser": {
      "description": "A parser to extract key/value pairs from a string.\nIf duplicate keys are found, the first instance is used.",
      "properties": {
        "delimiter": {
          "description": "The string for splitting the input into key/value pairs.",
          "type": "string"
        },
        "pair_separator": {
          "description": "The string for splitting each pair into its key and value.",
          "type": "string"
        },
        "trim_set": {
          "description": "Specifies the code points of any Unicode characters to trim from the\nbeginning and end of keys and values.",
          "type": "string"
        }
      },
      "required": [
        "delimiter",
        "pair_separator"
      ],
      "type": "object"
    },
    "LogParserParserType": {
      "enum": [
        "JSON",
        "REGEX",
        "KEY_VALUE",
        "GROK"
      ],
      "type": "string"
    },
    "LogParserRegexParser": {
      "properties": {
        "regex": {
          "description": "The regular expression parser pattern to apply. Must use RE2 syntax.\nNamed capturing groups become named fields in the extracted log.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "MappedValueReplacePair": {
      "properties": {
        "key": {
          "type": "string"
        },
        "value": {
          "type": "string"
        }
      },
      "type": "object"
    },
    "ReplaceFieldMappedValue": {
      "description": "MappedValue is the configuration for mapped value replace mode.",
      "properties": {
        "default_value": {
          "description": "The value to use if no matching value is found.",
          "type": "string"
        },
        "pairs": {
          "description": "A list of key/value pairs to replace matched content with.",
          "items": {
            "$ref": "#/$defs/MappedValueReplacePair"
          },
          "type": "array"
        },
        "use_default": {
          "description": "If `true`, specifies a default value if no matching key is found. If\n`false`, the value will be unchanged if no matching key is found.",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "ReplaceFieldReplaceMode": {
      "description": " - HASH: Replace the matched content with a hashed string, which can help reduce the\nsize of large strings. After replacing the original content with a string,\nthere’s no way to recover that information.\n - STATIC_VALUE: Replace the matched content with a static string. For example, replace\npunctuation in a field with an empty string, or truncate the ends of long\nstack traces.\n - MAPPED_VALUE: Replace the matched content with specified key/value pairs. For example,\nreduce log volume by replacing a string error with a specific error code. If\nnone of the key/value pairs match, the provided default value is used.\n\n@REQUIRED",
      "enum": [
        "HASH",
        "STATIC_VALUE",
        "MAPPED_VALUE"
      ],
      "type": "string"
    },
    "ReplaceFieldStaticValue": {
      "description": "StaticValue is the configuration for the replace field control rule in static value\nmode. Used to replace the selected content with a static value.",
      "properties": {
        "value": {
          "description": "The value to replace selected content with. If empty, the action removes the\nselected content.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "configv1LogControlConfig": {
      "description": "LogControlConfig is a singleton configuration object that specifies the\nconfiguration for log control.",
      "properties": {
        "created_at": {
          "description": "Timestamp of when the LogControlConfig was created. Cannot be set by clients.",
          "format": "date-time",
          "readOnly": true,
          "type": "string"
        },
        "rules": {
          "description": "Control Rules are the ordered list of control rules.",
          "items": {
            "$ref": "#/$defs/configv1LogControlRule"
          },
          "type": "array"
        },
        "updated_at": {
          "description": "Timestamp of when the LogControlConfig was last updated. Cannot be set by clients.",
          "format": "date-time",
          "readOnly": true,
          "type": "string"
        }
      },
      "type": "object"
    },
    "configv1LogControlRule": {
      "description": "LogControlRule is the configuration for a log control rule.",
      "properties": {
        "drop_field": {
          "allOf": [
            {
              "$ref": "#/$defs/LogControlRuleDropField"
            }
          ],
          "description": "Defines the action to drop fields from logs that match specified conditions,\nwhich helps reduce the size of individual logs. If a log contains no data after\nfields are dropped, you can choose to drop the entire log."
        },
        "emit_metrics": {
          "allOf": [
            {
              "$ref": "#/$defs/LogControlRuleEmitMetrics"
            }
          ],
          "description": "Defines the action to convert log data to metric data. Use this control rule\nwhen you want to reduce the volume of logs, retain data for a longer period, and\nincrease the speed of querying and filtering for metrics instead of logs"
        },
        "filter": {
          "description": "Log query filter to return log data for the control rule. The control action\napplies to only matching logs.",
          "type": "string"
        },
        "mode": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogControlRuleMode"
            }
          ],
          "description": "Specifies whether the control rule is enabled or disabled. Default: `ENABLED`."
        },
        "name": {
          "description": "User-defined name of the control rule.",
          "type": "string"
        },
        "parse_field": {
          "allOf": [
            {
              "$ref": "#/$defs/LogControlRuleParseField"
            }
          ],
          "description": "Defines the action to parse a field in your structured log data. Use this \ncontrol rule when you want to parse a field in your log data and store the \nparsed data in a field or multiple new fields."
        },
        "replace_field": {
          "allOf": [
            {
              "$ref": "#/$defs/LogControlRuleReplaceField"
            }
          ],
          "description": "Defines the action to identify a specified field in your log data and uses a\nregular expression to replace any matches based on the selected replacement\nmode. Use this control rule to truncate long fields and preserve your log\nstructure."
        },
        "sample": {
          "allOf": [
            {
              "$ref": "#/$defs/LogControlRuleSample"
            }
          ],
          "description": "Defines the action to retain a certain percentage of matching logs and drop the\nremainder, which can significantly reduce volume and maintain visibility."
        },
        "type": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogControlRuleType"
            }
          ],
          "description": "The type of action to take on matching logs. Must be one of the following\nvalues."
        }
      },
      "type": "object"
    },
    "configv1LogControlRuleMode": {
      "enum": [
        "ENABLED",
        "DISABLED"
      ],
      "type": "string"
    },
    "configv1LogControlRuleType": {
      "enum": [
        "DROP",
        "SAMPLE",
        "DROP_FIELD",
        "REPLACE_FIELD",
        "EMIT_METRICS",
        "PARSE_FIELD"
      ],
      "type": "string"
    },
    "configv1LogFieldPath": {
      "properties": {
        "selector": {
          "description": "The log filter used to indicate the field path. Use `parent[child]` syntax to\nindicate nesting.",
          "type": "string"
        }
      },
      "type": "object"
    }
  }
}