diff --git a/logs/analyze.go b/logs/analyze.go index 6516bc511..8b5b21990 100644 --- a/logs/analyze.go +++ b/logs/analyze.go @@ -15,7 +15,20 @@ import ( ) type match struct { - prefixes []string + prefixes []string + // regexp should match valid log lines for the given log line type, but should + // also be resilient to bugs in log line stitching (see logs.NewStitchBuffer + // and its callers). If we end our match with a loose regex term and another + // totally independent line ends up tagged onto the end of our line (which + // could happen with or without a joining newline), we could end up capturing + // PII without the proper secret markers for redaction. + // + // To avoid this, don't use overly broad matchers like `.*` or `.+`. regexp is + // matched WITHOUT the (?m)/(?s) flags, so `.` never matches a newline, but we + // should be resilient against missing newlines. + // + // Prefer a restrictive positive character class where possible. A negated + // class like [^"]+ DOES match "\n", so it can cross lines. regexp *regexp.Regexp secrets []state.LogSecretKind remainderKind state.LogSecretKind @@ -739,8 +752,10 @@ var checkConstraintViolation1 = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_CHECK_CONSTRAINT_VIOLATION, primary: match{ prefixes: []string{"new row for relation"}, - regexp: regexp.MustCompile(`^new row for relation "(.+?)" violates check constraint "(.+?)"`), - secrets: []state.LogSecretKind{0, 0}, + // A partition constraint violation shares errcode 23514 (check_violation) with a check + // constraint violation and comes with the same "Failing row contains (...)" detail line. + regexp: regexp.MustCompile(`^new row for relation "(.+?)" violates (?:check constraint "(.+?)"|partition constraint)`), + secrets: []state.LogSecretKind{0, 0}, // FIXME: Store constraint name and relation name }, detail: match{ @@ -775,6 +790,74 @@ var checkConstraintViolation4 = analyzeGroup{ // FIXME: Store constraint name }, } + +// partitionConstraintViolation covers the runtime/data partition errors, which share errcode 23514 +// (check_violation) with the check-constraint violations above (and with the "new row for relation +// ... violates partition constraint" form handled by checkConstraintViolation1): a row that routes +// to no partition, or a bulk ATTACH/default-partition validation failing for some existing row. The +// DDL-level partition errors (invalid bounds, overlap, unsupported features) use other errcodes and +// are handled by partitionError (PARTITION_ERROR). +var partitionConstraintViolation = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_CHECK_CONSTRAINT_VIOLATION, + primary: match{ + prefixes: []string{"no partition of relation", "partition constraint of relation", "updated partition constraint for default partition"}, + regexp: regexp.MustCompile(`^(?:no partition of relation "[^"]+" found for row` + + `|partition constraint of relation "[^"]+" is violated by some row` + + `|updated partition constraint for default partition "[^"]+" would be violated by some row)`), + secrets: []state.LogSecretKind{}, + }, + detail: match{ + regexp: regexp.MustCompile(`^Partition key of the failing row contains (.+)\.`), + secrets: []state.LogSecretKind{state.TableDataLogSecret}, + }, +} + +// withCheckOptionViolation: a row written through a WITH CHECK OPTION view falls outside the view's +// condition (errcode 44000). Carries the same data-bearing "Failing row contains ..." detail as the +// constraint violations. +var withCheckOptionViolation = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_WITH_CHECK_OPTION_VIOLATION, + primary: match{ + prefixes: []string{"new row violates check option for view"}, + regexp: regexp.MustCompile(`^new row violates check option for view "[^"]+"`), + secrets: []state.LogSecretKind{}, + }, + detail: match{ + regexp: regexp.MustCompile(`^Failing row contains \((.+)\).`), + secrets: []state.LogSecretKind{state.TableDataLogSecret}, + }, +} + +// cannotModifyView: DML targeting a view (or a view column) that is not auto-updatable. Postgres +// splits this across errcode 55000 (whole view) and 0A000 (specific column), but it is one +// user-facing problem. View/column names are identifiers, so nothing is redacted. +var cannotModifyView = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_CANNOT_MODIFY_VIEW, + primary: match{ + prefixes: []string{ + "cannot insert into view", "cannot insert into column", "cannot update view", + "cannot update column", "cannot delete from view", "cannot merge into view", + "cannot merge into column", + }, + regexp: regexp.MustCompile(`^cannot (?:insert into|update|delete from|merge into) (?:column "[^"]+" of )?view "[^"]+"(?: using FOR PORTION OF "[^"]*")?`), + secrets: []state.LogSecretKind{}, + }, +} + +// rowLevelSecurityViolation covers the runtime RLS denials (errcode 42501 insufficient_privilege): +// a write blocked by a policy's WITH CHECK / USING expression, or a read/write refused because it +// would be affected by a policy. RLS policy *definition* errors (e.g. "infinite recursion detected +// in policy") use other errcodes and are left unclassified. Table/policy names are identifiers, so +// nothing is redacted. +var rowLevelSecurityViolation = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_ROW_LEVEL_SECURITY_VIOLATION, + primary: match{ + prefixes: []string{"new row violates row-level security policy", "target row violates row-level security policy", "query would be affected by row-level security policy"}, + regexp: regexp.MustCompile(`^(?:(?:new|target) row violates row-level security policy(?: "[^"]*")?(?: \(USING expression\))? for table "[^"]+"` + + `|query would be affected by row-level security policy for table "[^"]+")`), + secrets: []state.LogSecretKind{}, + }, +} var exclusionConstraintViolation = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_EXCLUSION_CONSTRAINT_VIOLATION, primary: match{ @@ -808,8 +891,11 @@ var columnDoesNotExist = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_COLUMN_DOES_NOT_EXIST, primary: match{ prefixes: []string{"column"}, - regexp: regexp.MustCompile(`^column (?:"[^"]+"|[\w.]+) does not exist(?: at character \d+)?`), - secrets: []state.LogSecretKind{}, + // Also covers the "column ... does not exist" variants that carry extra context (referenced in + // a foreign key, named in a (partition) key, or "column number N of relation ...") - all + // errcode 42703. The "of relation ..." form is handled by columnDoesNotExistOnTable. + regexp: regexp.MustCompile(`^column (?:number \d+ of relation "[^"]+"|(?:"[^"]+"|[\w.]+)(?: referenced in foreign key constraint| named in (?:partition )?key)?) does not exist(?: at character \d+)?`), + secrets: []state.LogSecretKind{}, }, } var columnDoesNotExistOnTable = analyzeGroup{ @@ -831,16 +917,21 @@ var columnReferenceAmbiguous = analyzeGroup{ var relationDoesNotExist = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_RELATION_DOES_NOT_EXIST, primary: match{ - prefixes: []string{"relation"}, - regexp: regexp.MustCompile(`^relation "([^"]+)" does not exist(?: at character \d+)?`), + // table/sequence/view/materialized view share errcode 42P01 (undefined_table) with the + // generic "relation" form (emitted by wrongRelkindError), so they are the same class. + prefixes: []string{"relation", "table", "sequence", "view", "materialized view"}, + regexp: regexp.MustCompile(`^(?:relation|table|sequence|view|materialized view) "([^"]+)" does not exist(?: at character \d+)?`), secrets: []state.LogSecretKind{0}, }, } var functionDoesNotExist = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_FUNCTION_DOES_NOT_EXIST, primary: match{ - prefixes: []string{"function"}, - regexp: regexp.MustCompile(`^function ([^"]+) does not exist(?: at character \d+)?`), + // procedure/aggregate/routine share errcode 42883 (undefined_function) with function. The + // name is matched with .+? (not [^"]+) so quoted names ("function \"foo\" does not exist", + // emitted when there is no argument list) match too, not just "name(args)" signatures. + prefixes: []string{"function", "procedure", "aggregate", "routine"}, + regexp: regexp.MustCompile(`^(?:function|procedure|aggregate|routine) (.+?) does not exist(?: at character \d+| in operator family "[^"]*")?`), secrets: []state.LogSecretKind{0}, }, hint: match{ @@ -922,22 +1013,133 @@ var operatorDoesNotExist = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_OPERATOR_DOES_NOT_EXIST, primary: match{ prefixes: []string{"operator does not exist: "}, - regexp: regexp.MustCompile(`^operator does not exist: (\w+) ([` + regexp.QuoteMeta("+*/<>=~!@#%^&|`?-") + `]+) (\w+)(?: at character \d+)?`), - secrets: []state.LogSecretKind{0, 0, 0}, + // The remainder is a Postgres-generated operator/type description (e.g. + // "boolean || boolean", "@#@ integer", "time with time zone + time with + // time zone", schema-qualified "pg_catalog.+(int4,int4)"). + regexp: regexp.MustCompile(`^operator does not exist: [\w .,()\[\]` + regexp.QuoteMeta("+*/<>=~!@#%^&|`?-") + `]+`), + secrets: []state.LogSecretKind{}, }, hint: match{ prefixes: []string{"No operator matches the given name and argument type(s). You might need to add explicit type casts."}, }, } + +// objectDoesNotExist is the catch-all for " ... does not exist" errors whose object +// type has no dedicated classification (mostly errcode 42704 undefined_object, plus siblings like +// undefined_schema/database/cursor). Relations (table/sequence/view/... -> relationDoesNotExist), +// columns, functions (function/procedure/aggregate -> functionDoesNotExist) and the "operator does +// not exist: " form are handled by their own groups, matched earlier. +var objectDoesNotExist = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_OBJECT_DOES_NOT_EXIST, + primary: match{ + prefixes: []string{ + "role", "type", "index", "collation", "conversion", "cast", "extension", "language", + "server", "foreign", "user mapping", "mapping for token type", "event trigger", "trigger", + "subscription", "publication", "statistics object", "large object", "tablespace", + "access method", "operator", "rule", "policy", "constraint", "domain", "transform", + "text search", "token type", "property", "label", "schema", "database", "cursor", + "prepared statement", "savepoint", "snapshot", "directory", "tablesample method", + }, + regexp: regexp.MustCompile(`^(?:` + + `role|type|index|collation|conversion|cast|extension|language|` + + `foreign-data wrapper|foreign server|foreign table|server|` + + `user mapping|mapping for token type|event trigger|trigger|` + + `subscription|publication|statistics object|large object|tablespace|` + + `access method|operator class|operator family|operator \d+|` + + `rule|policy|constraint|domain|transform|` + + `text search (?:parser|dictionary|template|configuration)|` + + `token type|property graph|property|label|schema|database|cursor|` + + `prepared statement|savepoint|snapshot|directory|tablesample method` + + `)\b.*does not exist(?: at character \d+| (?:for|in) [\w ]+ "[^"]*")?`), + secrets: []state.LogSecretKind{}, + }, +} + +// objectAlreadyExists is the mirror of objectDoesNotExist for duplicate-object DDL conflicts +// (" ... already exists"), spanning the duplicate_* errcodes (42710, 42P07, 42701, +// 42723). One broad bucket over all object types; content is identifiers, so nothing is redacted. +var objectAlreadyExists = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_OBJECT_ALREADY_EXISTS, + primary: match{ + prefixes: []string{ + "role", "type", "constraint", "column", "trigger", "relation", "schema", "database", + "sequence", "index", "view", "materialized view", "foreign table", "server", "foreign", + "user mapping", "event trigger", "subscription", "publication", "statistics object", + "tablespace", "operator", "rule", "policy", "conversion", "default conversion", "collation", + "cast", "language", "extension", "text search", "enum label", "function", "aggregate", + "procedure", "prepared statement", "domain", "property graph", "alias", + }, + regexp: regexp.MustCompile(`^(?:` + + `role|type|constraint|column|trigger|relation|schema|database|sequence|index|` + + `materialized view|foreign table|view|foreign-data wrapper|foreign server|server|` + + `user mapping|event trigger|subscription|publication|statistics object|tablespace|` + + `operator|rule|policy|(?:default )?conversion|collation|cast|language|extension|` + + `text search (?:parser|dictionary|template|configuration)|enum label|function|aggregate|` + + `procedure|prepared statement|domain|property graph|alias` + + `)\b.*already exists(?: (?:for|in) [\w ]+ "[^"]*")?(?: at character \d+)?`), + secrets: []state.LogSecretKind{}, + }, +} + +// wrongObjectType covers operations attempted on the wrong kind of object (mostly errcode 42809; the +// partition variants below are also 42P17/0A000): +// "\"...\" is [not] a[n] " and "ALTER action ... cannot be performed on relation ...". +// Includes the partition wrong-object-type phrasings ("\"...\" is [not] a partition[ed] ...", "is not +// a partition of ...") - these read as wrong-object-type errors and are preferred over the broad +// partitionError bucket, so this group is matched ahead of it. The non-object "\"...\" is not a ..." +// forms (valid hex/binary digit, scalar variable, valid base type, ...) use other errcodes and are +// excluded by enumerating only object-kind words. +var wrongObjectType = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_WRONG_OBJECT_TYPE, + primary: match{ + prefixes: []string{"\"", "relation", "ALTER action"}, + regexp: regexp.MustCompile(`^(?:` + + `"[^"]*" is (?:not )?an? (?:table or materialized view|materialized view|foreign table|` + + `BRIN index|unique index|index for table "[^"]*"|table|view|sequence|index|` + + `domain|property graph)` + + `|"[^"]*" is (?:not |already )?(?:an? )?(?:hash )?partition(?:ed(?: table)?| of (?:partitioned table|relation) "[^"]*")?` + + `|relation "[^"]*" is not a partition of relation "[^"]*"` + + `|ALTER action .+ cannot be performed on relation "[^"]*")(?: at character \d+)?`), + secrets: []state.LogSecretKind{}, + }, +} + +// skippingMaintenancePermissionDenied matches the WARNING-level messages emitted when a manual +// VACUUM/ANALYZE/CLUSTER/REPACK skips a relation the current role lacks privileges on. These are +// not query-level permission failures (the command still succeeds), so they get their own +// classification rather than being grouped with PERMISSION_DENIED. It is matched ahead of +// permissionDenied to keep those lines out of that group. +var skippingMaintenancePermissionDenied = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_SKIPPING_MAINTENANCE_PERMISSION_DENIED, + primary: match{ + prefixes: []string{"permission denied to analyze ", "permission denied to vacuum ", "permission denied to execute "}, + regexp: regexp.MustCompile(`^permission denied to (?:analyze|vacuum|execute (?:CLUSTER|REPACK) on) "([^"]+)", skipping it`), + secrets: []state.LogSecretKind{0}, + }, +} var permissionDenied = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_PERMISSION_DENIED, primary: match{ prefixes: []string{"permission denied"}, - regexp: regexp.MustCompile(`^permission denied for (?:column|relation|table|sequence|database|function|operator|type|language|large object|schema|operator class|operator family|collation|conversion|tablespace|text search dictionary|text search configuration|foreign-data wrapper|foreign server|event trigger|extension) ([\w_-]+)(?: at character \d+)?`), - secrets: []state.LogSecretKind{0}, + // Covers the three Postgres forms: + // "permission denied for " (object type can be multi-word, e.g. + // "foreign-data wrapper", "materialized view"; name may be quoted) + // "permission denied to " (e.g. "to grant role ...", "to create database") + // "permission denied: \"...\" is a system catalog" + // The "..., skipping it" warnings are handled earlier by skippingMaintenancePermissionDenied. + regexp: regexp.MustCompile(`^permission denied(?: for [\w -]+ (?:"[^"]*"|\S+)(?: at character \d+)?| to .+|: .+)?`), + secrets: []state.LogSecretKind{}, // FIXME: Store relation name when this is "permission denied for relation [relation name]" }, } +var mustBePrivilege = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_PERMISSION_DENIED, + primary: match{ + prefixes: []string{"must be owner of ", "must be able to SET ROLE ", "must be superuser "}, + regexp: regexp.MustCompile(`^must be (?:owner of [\w -]+ (?:"[^"]*"|\S+)|able to SET ROLE "[^"]*"|superuser [\w ]+)`), + secrets: []state.LogSecretKind{}, + }, +} var transactionIsAborted = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_TRANSACTION_IS_ABORTED, primary: match{ @@ -991,7 +1193,54 @@ var cannotDrop = analyzeGroup{ var integerOutOfRange = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_INTEGER_OUT_OF_RANGE, primary: match{ - prefixes: []string{"integer out of range"}, + prefixes: []string{"integer out of range", "bigint out of range", "smallint out of range", "value \""}, + regexp: regexp.MustCompile(`^(?:(?:integer|bigint|smallint) out of range|value "([^"]*)" is out of range for type (?:smallint|integer|bigint)(?: at character \d+)?)`), + secrets: []state.LogSecretKind{state.TableDataLogSecret}, + }, +} + +// valueOutOfRange covers out-of-range/overflow errors for non-integer types (numeric, money, +// float, date/time, interval, timestamp, oid, block number, etc.); integer types are handled by +// integerOutOfRange (matched earlier). Where the message carries a user-supplied value it is +// captured and redacted. Container-index errors ("array subscript out of range", jsonb "path +// element ... is out of range") are not value-does-not-fit-the-type errors and are left unclassified +// on purpose; the jsonpath .decimal()/.time() precision/scale errors are SQL_JSON_ERROR. +var valueOutOfRange = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_VALUE_OUT_OF_RANGE, + primary: match{ + prefixes: []string{ + "interval field value out of range", "date/time field value out of range", + "date field value out of range", "time field value out of range", + "interval out of range", "timestamp out of range", "date out of range", + "numeric field overflow", "value overflows numeric format", "value out of range", + "money out of range", "result is out of range", "input is out of range", + "pg_lsn out of range", "OID out of range", "time zone displacement out of range", + "numeric time zone", "block number out of range", "value \"", "value for \"", + "MINVALUE", "MAXVALUE", "\"", + }, + regexp: regexp.MustCompile(`^(?:` + + `(?:interval|date/time|date|time) field value out of range: (?:"([^"]*)"|(\S+))` + + `|(?:timestamp|date|interval) out of range(?:: "([^"]*)")?` + + `|(?:value )?"([^"]*)" is out of range for type [\w ]+` + + `|value for "([^"]*)" in source string is out of range` + + `|time zone displacement out of range: "([^"]*)"` + + `|numeric time zone "([^"]*)" out of range` + + `|(?:MINVALUE|MAXVALUE) \([^)]*\) is out of range for sequence data type \w+` + + `|block number out of range: -?\d+` + + `|numeric field overflow` + + `|value overflows numeric format` + + `|value out of range: (?:overflow|underflow)` + + `|money out of range` + + `|result is out of range` + + `|input is out of range` + + `|pg_lsn out of range` + + `|OID out of range` + + `)(?: for [\w ]+)?(?: at character \d+)?`), + secrets: []state.LogSecretKind{ + state.TableDataLogSecret, state.TableDataLogSecret, state.TableDataLogSecret, + state.TableDataLogSecret, state.TableDataLogSecret, state.TableDataLogSecret, + state.TableDataLogSecret, + }, }, } var invalidRegexp = analyzeGroup{ @@ -1106,6 +1355,147 @@ var inconsistentRangeBounds = analyzeGroup{ prefixes: []string{"range lower bound must be less than or equal to range upper bound"}, }, } + +// partitionError is the catch-all for partitioning DDL/operation errors +// (invalid bound/key definitions, overlaps, cannot attach/detach/merge/split). +// Runtime row-routing and partition-constraint failures are handled earlier by +// partitionConstraintViolation / checkConstraintViolation1 +// (CHECK_CONSTRAINT_VIOLATION), and the wrong-object-type phrasings ("\"X\" is +// [not] a partition[ed] ...") by wrongObjectType - both matched ahead of this +// group. The generic "ALTER action ... cannot be performed on relation ..." +// family is not partition-specific and is handled by wrongObjectType +// (WRONG_OBJECT_TYPE). +var partitionError = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_PARTITION_ERROR, + primary: match{ + prefixes: []string{ + "partition", "partitioned", "partitions", "cannot", "column", "trigger", + "invalid bound specification", "empty range bound specified", "remainder for hash partition", + "modulus for hash partition", "every hash partition", "a hash-partitioned table", + "number of partitioning columns", "unrecognized partitioning strategy", + "aggregate functions are not allowed in partition", "window functions are not allowed in partition", + "set-returning functions are not allowed in partition", "functions in partition key expression", + "UNIQUE constraint on partitioned", "PRIMARY KEY constraint on partitioned", + "EXCLUDE constraint on partitioned", "unsupported UNIQUE constraint", "unsupported PRIMARY KEY constraint", + "not-null constraint", "identity columns are not supported on partitions", "removing partition", + "upper bound of partition", "lower bound of partition", "new partition", "list of new partitions", + "list of partitions to be merged", "moving row to another partition", + "ROW triggers with transition tables", "TO must specify", "FROM must specify", + }, + regexp: regexp.MustCompile(`^(?:` + + `partition "[^"]*" (?:would overlap partition "[^"]*"|conflicts with existing default partition "[^"]*")(?: at character \d+)?` + + `|partition "[^"]*" (?:already pending detach in partitioned table "[^"]*"|was removed concurrently)` + + `|partition with name "[^"]*" is already used(?: at character \d+)?` + + `|partition key column \S+ has pseudo-type \w+` + + `|partition key expressions cannot contain system column references` + + `|partition of hash-partitioned table cannot be (?:split|merged)` + + `|partitions being merged have different owners` + + `|partitioned table "[^"]*" was removed concurrently` + + `|partitioned tables cannot be unlogged` + + `|cannot .+(?i:partition).*` + + `|invalid bound specification for a \w+ partition(?: at character \d+)?` + + `|empty range bound specified for partition "[^"]*"(?: at character \d+)?` + + `|(?:remainder|modulus) for hash partition .+` + + `|every hash partition modulus must be a factor of the next larger modulus` + + `|a hash-partitioned table may not have a default partition` + + `|number of partitioning columns \(\d+\) does not match number of partition keys provided \(\d+\)` + + `|unrecognized partitioning strategy "[^"]*"(?: at character \d+)?` + + `|column \d+ of the partition key .+` + + `|(?:aggregate|window|set-returning) functions are not allowed in partition (?:bound(?: at character \d+)?|key expressions)` + + `|functions in partition key expression must be marked IMMUTABLE` + + `|(?:UNIQUE|PRIMARY KEY|EXCLUDE) constraint on partitioned table must include all partitioning columns` + + `|unsupported (?:UNIQUE|PRIMARY KEY) constraint with partition key definition` + + `|not-null constraints? .*partitioned tables?(?: "[^"]*")? cannot be NO INHERIT` + + `|identity columns are not supported on partitions` + + `|removing partition "[^"]*" violates foreign key constraint "[^"]*"` + + `|(?:upper|lower) bound of partition "[^"]*" .+` + + `|(?:new partition|new partitions'|list of (?:new partitions|partitions to be merged)) .+` + + `|moving row to another partition during a BEFORE FOR EACH ROW trigger is not supported` + + `|trigger "[^"]*" prevents table "[^"]*" from becoming a partition` + + `|ROW triggers with transition tables are not supported on partitions` + + `|(?:TO|FROM) must specify exactly one value per partitioning column` + + `)`), + secrets: []state.LogSecretKind{}, + }, +} + +// SQL/JSON errors (JSON / jsonpath / SQL-JSON functions) span many errcodes, but form one useful +// category. They are split into three groups by what needs redacting, matched in this order so the +// data-bearing forms redact their value before the broad no-data group claims the line: +// +// sqlJsonErrorData - a user value/key from the data (TableData) +// sqlJsonParseError - jsonpath source text near a parse error (ParsingError) +// sqlJsonError - everything else: fixed text + identifiers (method/type/column/variable names) +var sqlJsonErrorData = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_SQL_JSON_ERROR, + primary: match{ + prefixes: []string{"argument \"", "duplicate JSON object key value", "JSON object does not contain key"}, + regexp: regexp.MustCompile(`^(?:argument "([^"]*)" of jsonpath item method \.\w+\(\) is invalid for type [\w ]+` + + `|duplicate JSON object key value(?:: "([^"]*)")?` + + `|JSON object does not contain key "([^"]*)")`), + secrets: []state.LogSecretKind{state.TableDataLogSecret, state.TableDataLogSecret, state.TableDataLogSecret}, + }, +} +var sqlJsonParseError = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_SQL_JSON_ERROR, + primary: match{ + prefixes: []string{"trailing junk after numeric literal", "invalid Unicode escape sequence"}, + // Only the jsonpath-input variants belong here; the plain-SQL "... at character N" forms are + // left for a syntax-error classification, so the regex requires "of jsonpath input". + regexp: regexp.MustCompile(`^(?:trailing junk after numeric literal|invalid Unicode escape sequence) at or near "([^"]*)" of jsonpath input(?: at character \d+)?`), + secrets: []state.LogSecretKind{state.ParsingErrorLogSecret}, + }, +} +var sqlJsonError = analyzeGroup{ + classification: pganalyze_collector.LogLineInformation_SQL_JSON_ERROR, + primary: match{ + prefixes: []string{ + "jsonpath", "left operand of jsonpath", "right operand of jsonpath", "operand of unary jsonpath", + "precision of jsonpath", "scale of jsonpath", "time precision of jsonpath", "field position of jsonpath", + "NaN or Infinity is not allowed for jsonpath", "could not find jsonpath", "syntax error at end of jsonpath", + "no SQL/JSON item found", "JSON path expression", "expected JSON array", "malformed JSON array", + "JSON value must not be null", "key value must be scalar", "cannot cast jsonb", "cannot cast type", + "cannot call json", "could not determine row type for result of json", "JSON_TABLE", "invalid JSON_TABLE", + "duplicate JSON_TABLE", "only string constants are supported in JSON_TABLE", "cannot specify", "cannot use type", "cannot use non-string", + "cannot set JSON encoding", "returning pseudo-types is not supported in SQL/JSON", "SQL/JSON QUOTES", + "null_value_treatment must be", "unsupported JSON encoding", "unrecognized JSON encoding", "JSON ENCODING clause", + "COPY FORMAT JSON", "COPY FORCE_ARRAY", "jsonb subscript", + }, + regexp: regexp.MustCompile(`^(?:` + + `jsonpath (?:item method \.\w+\(\)|(?:wildcard )?member accessor|(?:wildcard )?array accessor|array subscript) .+` + + `|(?:(?:left|right) operand of|operand of unary) jsonpath operator \S+ is not a (?:single )?numeric value` + + `|(?:precision|scale|time precision|field position) of jsonpath item method \.\w+\(\) (?:is out of range for type integer|must not be zero)` + + `|NaN or Infinity is not allowed for jsonpath item method \.\w+\(\)` + + `|could not find jsonpath variable "[^"]*"` + + `|syntax error at end of jsonpath input(?: at character \d+)?` + + `|no SQL/JSON item found for specified path(?: of column "[^"]*")?` + + `|JSON path expression .+` + + `|expected JSON array` + + `|malformed JSON array` + + `|JSON value must not be null` + + `|key value must be scalar, not array, composite, or json` + + `|cannot cast jsonb .+ to type [\w ]+` + + `|cannot cast type [\w ]+ to json(?: at character \d+)?` + + `|cannot call jsonb?_object_keys on (?:a scalar|an array)` + + `|could not determine row type for result of jsonb?_populate_record(?:set)?` + + `|(?:invalid )?JSON_TABLE .+` + + `|duplicate JSON_TABLE column or path name: \S+(?: at character \d+)?` + + `|only string constants are supported in JSON_TABLE path specification(?: at character \d+)?` + + `|cannot specify (?:\w+ in JSON mode|FORMAT JSON in RETURNING clause of JSON_\w+\(\))(?: at character \d+)?` + + `|cannot use (?:type [\w ]+ in (?:IS JSON predicate|RETURNING clause of JSON_\w+\(\))|non-string types with explicit FORMAT JSON clause)(?: at character \d+)?` + + `|cannot set JSON encoding for non-bytea output types(?: at character \d+)?` + + `|returning pseudo-types is not supported in SQL/JSON functions` + + `|SQL/JSON QUOTES behavior must not be specified when WITH WRAPPER is used(?: at character \d+)?` + + `|null_value_treatment must be .+` + + `|(?:unsupported JSON encoding|unrecognized JSON encoding: \w+)(?: at character \d+)?` + + `|JSON ENCODING clause is only allowed for bytea input type(?: at character \d+)?` + + `|COPY FORMAT JSON is not supported for COPY FROM` + + `|COPY FORCE_ARRAY can only be used with JSON mode` + + `|jsonb subscript (?:does not support slices|in assignment must not be null)(?: at character \d+)?` + + `)`), + secrets: []state.LogSecretKind{}, + }, +} var statementLog = analyzeGroup{ classification: pganalyze_collector.LogLineInformation_STATEMENT_LOG, primary: match{ @@ -1202,6 +1592,20 @@ func AnalyzeLogLines(logLinesIn []state.LogLine) (logLinesOut []state.LogLine, s func classifyAndSetDetails(logLine state.LogLine, statementLine state.LogLine, detailLine state.LogLine, contextLine state.LogLine, hintLine state.LogLine, samples []state.PostgresQuerySample) (state.LogLine, state.LogLine, state.LogLine, state.LogLine, state.LogLine, []state.PostgresQuerySample) { var parts []string + // Handled ahead of the generic handlers (which include permissionDenied) so + // these "..., skipping it" warnings are not swept into PERMISSION_DENIED. + // Also extracts the skipped relation name, which Postgres logs without a + // schema. + if matchesPrefix(logLine, skippingMaintenancePermissionDenied.primary.prefixes) { + logLine, parts = matchLogLine(logLine, skippingMaintenancePermissionDenied.primary) + if len(parts) == 2 { + logLine.Classification = skippingMaintenancePermissionDenied.classification + logLine.Details = map[string]interface{}{"relation_name": parts[1]} + contextLine = matchOtherContextLogLine(contextLine) + return logLine, statementLine, detailLine, contextLine, hintLine, samples + } + } + // Generic handlers groupX := []analyzeGroup{ connectionRejected, @@ -1253,6 +1657,10 @@ func classifyAndSetDetails(logLine state.LogLine, statementLine state.LogLine, d checkConstraintViolation2, checkConstraintViolation3, checkConstraintViolation4, + partitionConstraintViolation, + rowLevelSecurityViolation, + withCheckOptionViolation, + cannotModifyView, exclusionConstraintViolation, columnMissingFromGroupBy, columnDoesNotExist, @@ -1268,7 +1676,9 @@ func classifyAndSetDetails(logLine state.LogLine, statementLine state.LogLine, d insertTargetColumnMismatch, anyAllRequiresArray, operatorDoesNotExist, + objectDoesNotExist, permissionDenied, + mustBePrivilege, transactionIsAborted, onConflictNoConstraintMatch, onConflictRowAffectedTwice, @@ -1276,6 +1686,7 @@ func classifyAndSetDetails(logLine state.LogLine, statementLine state.LogLine, d divisionByZero, cannotDrop, integerOutOfRange, + valueOutOfRange, invalidRegexp, paramMissing, noSuchSavepoint, @@ -1285,6 +1696,12 @@ func classifyAndSetDetails(logLine state.LogLine, statementLine state.LogLine, d couldNotSerializeRepeatableRead, couldNotSerializeSerializable, inconsistentRangeBounds, + objectAlreadyExists, + wrongObjectType, + partitionError, + sqlJsonErrorData, + sqlJsonParseError, + sqlJsonError, } for _, m := range groupX { if matchesPrefix(logLine, m.primary.prefixes) { @@ -1581,7 +1998,7 @@ func classifyAndSetDetails(logLine state.LogLine, statementLine state.LogLine, d } } - // Autovacuum + // Maintenance if matchesPrefix(logLine, autovacuumCancel.primary.prefixes) { logLine, parts = matchLogLine(logLine, autovacuumCancel.primary) if parts != nil { diff --git a/logs/analyze_test.go b/logs/analyze_test.go index 11c70c1a5..2bca9a268 100644 --- a/logs/analyze_test.go +++ b/logs/analyze_test.go @@ -1173,7 +1173,7 @@ var tests = []testpair{ }}, nil, }, - // Autovacuum + // Maintenance { []state.LogLine{{ Content: "canceling autovacuum task", @@ -3967,6 +3967,581 @@ index scan needed: 1 pages from table (100.00% of total) had 60 dead item identi }}, nil, }, + // bigint/smallint out of range are the same class as integer out of range + { + []state.LogLine{{ + Content: "bigint out of range", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_INTEGER_OUT_OF_RANGE, + ReviewedForSecrets: true, + }}, + nil, + }, + { + []state.LogLine{{ + Content: "value \"32768\" is out of range for type smallint at character 25", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_INTEGER_OUT_OF_RANGE, + ReviewedForSecrets: true, + SecretMarkers: []state.LogSecretMarker{{ + ByteStart: 7, + ByteEnd: 12, + Kind: state.TableDataLogSecret, + }}, + }}, + nil, + }, + // Non-integer out-of-range/overflow errors are VALUE_OUT_OF_RANGE; the offending value is redacted + { + []state.LogLine{{ + Content: "interval field value out of range: \"P1Y2M3D\" at character 20", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_VALUE_OUT_OF_RANGE, + ReviewedForSecrets: true, + SecretMarkers: []state.LogSecretMarker{{ + ByteStart: 36, + ByteEnd: 43, + Kind: state.TableDataLogSecret, + }}, + }}, + nil, + }, + { + []state.LogLine{{ + Content: "\"1e400\" is out of range for type double precision at character 12", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_VALUE_OUT_OF_RANGE, + ReviewedForSecrets: true, + SecretMarkers: []state.LogSecretMarker{{ + ByteStart: 1, + ByteEnd: 6, + Kind: state.TableDataLogSecret, + }}, + }}, + nil, + }, + // Fixed-form out-of-range messages carry no user value, so nothing is redacted. "block number + // out of range" is included: the number exceeds the range of the (uint32) block number type. + { + []state.LogLine{{ + Content: "numeric field overflow", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "timestamp out of range", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "block number out of range: 4294967296", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_VALUE_OUT_OF_RANGE, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_VALUE_OUT_OF_RANGE, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_VALUE_OUT_OF_RANGE, + ReviewedForSecrets: true, + }}, + nil, + }, + // "does not exist" family: relkinds fold into RELATION_, procedure/aggregate + quoted names into + // FUNCTION_, column variants into COLUMN_, and the long tail of object types into OBJECT_. + { + []state.LogLine{{ + Content: "table \"missing_tbl\" does not exist", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "procedure ptest9(integer) does not exist at character 8", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "function \"my_func\" does not exist", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "column \"c\" named in key does not exist", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "column number 4 of relation \"t\" does not exist", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "role \"regress_role\" does not exist", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "collation \"c\" for encoding \"UTF8\" does not exist at character 30", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "large object 999 does not exist", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_RELATION_DOES_NOT_EXIST, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_FUNCTION_DOES_NOT_EXIST, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_FUNCTION_DOES_NOT_EXIST, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_COLUMN_DOES_NOT_EXIST, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_COLUMN_DOES_NOT_EXIST, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_OBJECT_DOES_NOT_EXIST, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_OBJECT_DOES_NOT_EXIST, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_OBJECT_DOES_NOT_EXIST, + ReviewedForSecrets: true, + }}, + nil, + }, + // Runtime/data partition errors share errcode 23514 with check constraint violations. The + // "no partition ... found for row" form carries a data-bearing "Partition key ..." detail. + { + []state.LogLine{{ + Content: "no partition of relation \"measurement\" found for row", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + UUID: uuid.UUID{1}, + }, { + Content: "Partition key of the failing row contains (a) = (5).", + LogLevel: pganalyze_collector.LogLineInformation_DETAIL, + }, { + Content: "partition constraint of relation \"part_2\" is violated by some row", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_CHECK_CONSTRAINT_VIOLATION, + UUID: uuid.UUID{1}, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_DETAIL, + ParentUUID: uuid.UUID{1}, + ReviewedForSecrets: true, + SecretMarkers: []state.LogSecretMarker{{ + ByteStart: 42, + ByteEnd: 51, + Kind: state.TableDataLogSecret, + }}, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_CHECK_CONSTRAINT_VIOLATION, + ReviewedForSecrets: true, + }}, + nil, + }, + // WITH CHECK OPTION violation (44000) carries a data-bearing "Failing row contains" detail + { + []state.LogLine{{ + Content: "new row violates check option for view \"my_view\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + UUID: uuid.UUID{1}, + }, { + Content: "Failing row contains (1, 2).", + LogLevel: pganalyze_collector.LogLineInformation_DETAIL, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_WITH_CHECK_OPTION_VIOLATION, + UUID: uuid.UUID{1}, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_DETAIL, + ParentUUID: uuid.UUID{1}, + ReviewedForSecrets: true, + SecretMarkers: []state.LogSecretMarker{{ + ByteStart: 22, + ByteEnd: 26, + Kind: state.TableDataLogSecret, + }}, + }}, + nil, + }, + // Non-updatable view DML errors (55000 view-level, 0A000 column-level) share one classification + { + []state.LogLine{{ + Content: "cannot insert into view \"my_view\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "cannot update column \"c\" of view \"my_view\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "cannot delete from view \"my_view\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_CANNOT_MODIFY_VIEW, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_CANNOT_MODIFY_VIEW, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_CANNOT_MODIFY_VIEW, + ReviewedForSecrets: true, + }}, + nil, + }, + // Duplicate-object DDL conflicts (OBJECT_ALREADY_EXISTS) and wrong-object-type errors + // (WRONG_OBJECT_TYPE); the non-object "is not a valid ..." forms stay unclassified. + { + []state.LogLine{{ + Content: "relation \"foo\" already exists", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "column \"c\" of relation \"t\" already exists", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "function alt_func2(integer) already exists in schema \"s\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "\"foo\" is not an index", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "\"bar\" is a view", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "\"baz\" is not a partitioned table", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "\"qux\" is not a partition of partitioned table \"parent\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "ALTER action DETACH PARTITION cannot be performed on relation \"p\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_OBJECT_ALREADY_EXISTS, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_OBJECT_ALREADY_EXISTS, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_OBJECT_ALREADY_EXISTS, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_WRONG_OBJECT_TYPE, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_WRONG_OBJECT_TYPE, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_WRONG_OBJECT_TYPE, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_WRONG_OBJECT_TYPE, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_WRONG_OBJECT_TYPE, + ReviewedForSecrets: true, + }}, + nil, + }, + // Partitioning DDL/operation errors are one broad classification; nothing is redacted + { + []state.LogLine{{ + Content: "partition \"p1\" would overlap partition \"p2\" at character 20", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "cannot attach index \"idx\" as a partition of index \"pidx\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "cannot use column reference in partition bound expression at character 5", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "remainder for hash partition must be less than modulus", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "invalid bound specification for a range partition at character 10", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PARTITION_ERROR, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PARTITION_ERROR, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PARTITION_ERROR, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PARTITION_ERROR, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PARTITION_ERROR, + ReviewedForSecrets: true, + }}, + nil, + }, + // SQL/JSON errors: fixed-text forms redact nothing; forms carrying data/parse text redact it. + { + []state.LogLine{{ + Content: "jsonpath item method .string() can only be applied to a boolean, string, numeric, or datetime value", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "invalid JSON_TABLE specification at character 15", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "argument \"5x\" of jsonpath item method .integer() is invalid for type integer", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "duplicate JSON object key value: \"k\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "trailing junk after numeric literal at or near \"1x\" of jsonpath input at character 10", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_SQL_JSON_ERROR, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_SQL_JSON_ERROR, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_SQL_JSON_ERROR, + ReviewedForSecrets: true, + SecretMarkers: []state.LogSecretMarker{{ + ByteStart: 10, + ByteEnd: 12, + Kind: state.TableDataLogSecret, + }}, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_SQL_JSON_ERROR, + ReviewedForSecrets: true, + SecretMarkers: []state.LogSecretMarker{{ + ByteStart: 34, + ByteEnd: 35, + Kind: state.TableDataLogSecret, + }}, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_SQL_JSON_ERROR, + ReviewedForSecrets: true, + SecretMarkers: []state.LogSecretMarker{{ + ByteStart: 48, + ByteEnd: 50, + Kind: state.ParsingErrorLogSecret, + }}, + }}, + nil, + }, + // Runtime row-level security denials (errcode 42501) get their own classification + { + []state.LogLine{{ + Content: "new row violates row-level security policy for table \"accounts\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "new row violates row-level security policy \"acct_policy\" for table \"accounts\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "target row violates row-level security policy (USING expression) for table \"accounts\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "query would be affected by row-level security policy for table \"accounts\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_ROW_LEVEL_SECURITY_VIOLATION, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_ROW_LEVEL_SECURITY_VIOLATION, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_ROW_LEVEL_SECURITY_VIOLATION, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_ROW_LEVEL_SECURITY_VIOLATION, + ReviewedForSecrets: true, + }}, + nil, + }, + // "permission denied to " is a permission error (here: a role management command) + { + []state.LogLine{{ + Content: "permission denied to grant role \"regress_role\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PERMISSION_DENIED, + ReviewedForSecrets: true, + }}, + nil, + }, + // The WARNING-level "..., skipping it" messages from manual VACUUM/ANALYZE/CLUSTER/REPACK are + // classified separately from PERMISSION_DENIED (the command succeeds; some relations are skipped). + { + []state.LogLine{{ + Content: "permission denied to analyze \"my_table\", skipping it", + LogLevel: pganalyze_collector.LogLineInformation_WARNING, + }, { + Content: "permission denied to execute REPACK on \"my_table\", skipping it", + LogLevel: pganalyze_collector.LogLineInformation_WARNING, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_WARNING, + Classification: pganalyze_collector.LogLineInformation_SKIPPING_MAINTENANCE_PERMISSION_DENIED, + Details: map[string]interface{}{"relation_name": "my_table"}, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_WARNING, + Classification: pganalyze_collector.LogLineInformation_SKIPPING_MAINTENANCE_PERMISSION_DENIED, + Details: map[string]interface{}{"relation_name": "my_table"}, + ReviewedForSecrets: true, + }}, + nil, + }, + // permission denied for , where the object type ("view") was previously unmatched + { + []state.LogLine{{ + Content: "permission denied for view rw_view1", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PERMISSION_DENIED, + ReviewedForSecrets: true, + }}, + nil, + }, + // permission denied: "..." is a system catalog, and the bare "permission denied" + { + []state.LogLine{{ + Content: "permission denied: \"pg_authid\" is a system catalog", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "permission denied", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PERMISSION_DENIED, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PERMISSION_DENIED, + ReviewedForSecrets: true, + }}, + nil, + }, + // "must be owner of ...", "must be able to SET ROLE ...", "must be superuser ..." are privilege errors + { + []state.LogLine{{ + Content: "must be owner of foreign server s6", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "must be able to SET ROLE \"regress_role\"", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }, { + Content: "must be superuser to set ALL TABLES", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PERMISSION_DENIED, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PERMISSION_DENIED, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_PERMISSION_DENIED, + ReviewedForSecrets: true, + }}, + nil, + }, + // operator does not exist: unary operators and multi-word type names were previously unmatched + { + []state.LogLine{{ + Content: "operator does not exist: time with time zone + time with time zone at character 11", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_OPERATOR_DOES_NOT_EXIST, + ReviewedForSecrets: true, + }}, + nil, + }, + // partition constraint violation shares errcode/handling with check constraint violation + { + []state.LogLine{{ + Content: "new row for relation \"measurement\" violates partition constraint", + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + UUID: uuid.UUID{1}, + }, { + Content: "Failing row contains (-123).", + LogLevel: pganalyze_collector.LogLineInformation_DETAIL, + }}, + []state.LogLine{{ + LogLevel: pganalyze_collector.LogLineInformation_ERROR, + Classification: pganalyze_collector.LogLineInformation_CHECK_CONSTRAINT_VIOLATION, + UUID: uuid.UUID{1}, + ReviewedForSecrets: true, + }, { + LogLevel: pganalyze_collector.LogLineInformation_DETAIL, + ParentUUID: uuid.UUID{1}, + ReviewedForSecrets: true, + SecretMarkers: []state.LogSecretMarker{{ + ByteStart: 22, + ByteEnd: 26, + Kind: state.TableDataLogSecret, + }}, + }}, + nil, + }, { []state.LogLine{{ Content: "invalid regular expression: quantifier operand invalid", diff --git a/output/pganalyze_collector/compact_log_snapshot.pb.go b/output/pganalyze_collector/compact_log_snapshot.pb.go index 73305075a..148b5e3fc 100644 --- a/output/pganalyze_collector/compact_log_snapshot.pb.go +++ b/output/pganalyze_collector/compact_log_snapshot.pb.go @@ -218,16 +218,17 @@ const ( LogLineInformation_WAL_REDO LogLineInformation_LogClassification = 51 // "redo " LogLineInformation_WAL_ARCHIVE_COMMAND_FAILED LogLineInformation_LogClassification = 52 // "archive command failed" LogLineInformation_WAL_BASE_BACKUP_COMPLETE LogLineInformation_LogClassification = 53 // "pg_stop_backup complete, all required WAL segments have been archived" - // Autovacuum - LogLineInformation_AUTOVACUUM_CANCEL LogLineInformation_LogClassification = 60 // "canceling autovacuum task" - LogLineInformation_TXID_WRAPAROUND_WARNING LogLineInformation_LogClassification = 61 // "database * must be vacuumed within" - LogLineInformation_TXID_WRAPAROUND_ERROR LogLineInformation_LogClassification = 62 // "database is not accepting commands to avoid wraparound data loss" - LogLineInformation_AUTOVACUUM_LAUNCHER_STARTED LogLineInformation_LogClassification = 63 // "autovacuum launcher started" - LogLineInformation_AUTOVACUUM_LAUNCHER_SHUTTING_DOWN LogLineInformation_LogClassification = 64 // "autovacuum launcher shutting down", "terminating autovacuum process due to administrator command" - LogLineInformation_AUTOVACUUM_COMPLETED LogLineInformation_LogClassification = 65 // "automatic vacuum of table" - LogLineInformation_AUTOANALYZE_COMPLETED LogLineInformation_LogClassification = 66 // "automatic analyze of table" - LogLineInformation_SKIPPING_VACUUM_LOCK_NOT_AVAILABLE LogLineInformation_LogClassification = 67 // "skipping vacuum of ... --- lock not available" - LogLineInformation_SKIPPING_ANALYZE_LOCK_NOT_AVAILABLE LogLineInformation_LogClassification = 68 // "skipping analyze of ... --- lock not available" + // Maintenance + LogLineInformation_AUTOVACUUM_CANCEL LogLineInformation_LogClassification = 60 // "canceling autovacuum task" + LogLineInformation_TXID_WRAPAROUND_WARNING LogLineInformation_LogClassification = 61 // "database * must be vacuumed within" + LogLineInformation_TXID_WRAPAROUND_ERROR LogLineInformation_LogClassification = 62 // "database is not accepting commands to avoid wraparound data loss" + LogLineInformation_AUTOVACUUM_LAUNCHER_STARTED LogLineInformation_LogClassification = 63 // "autovacuum launcher started" + LogLineInformation_AUTOVACUUM_LAUNCHER_SHUTTING_DOWN LogLineInformation_LogClassification = 64 // "autovacuum launcher shutting down", "terminating autovacuum process due to administrator command" + LogLineInformation_AUTOVACUUM_COMPLETED LogLineInformation_LogClassification = 65 // "automatic vacuum of table" + LogLineInformation_AUTOANALYZE_COMPLETED LogLineInformation_LogClassification = 66 // "automatic analyze of table" + LogLineInformation_SKIPPING_VACUUM_LOCK_NOT_AVAILABLE LogLineInformation_LogClassification = 67 // "skipping vacuum of ... --- lock not available" + LogLineInformation_SKIPPING_ANALYZE_LOCK_NOT_AVAILABLE LogLineInformation_LogClassification = 68 // "skipping analyze of ... --- lock not available" + LogLineInformation_SKIPPING_MAINTENANCE_PERMISSION_DENIED LogLineInformation_LogClassification = 69 // "permission denied to {vacuum,analyze,execute CLUSTER on,execute REPACK on} ..., skipping it" // Locks LogLineInformation_LOCK_ACQUIRED LogLineInformation_LogClassification = 70 // "acquired *Lock" LogLineInformation_LOCK_WAITING LogLineInformation_LogClassification = 71 // "still waiting for *Lock" @@ -286,6 +287,15 @@ const ( LogLineInformation_COULD_NOT_SERIALIZE_REPEATABLE_READ LogLineInformation_LogClassification = 138 // "could not serialize access due to concurrent update" LogLineInformation_COULD_NOT_SERIALIZE_SERIALIZABLE LogLineInformation_LogClassification = 139 // "could not serialize access due to read/write dependencies among transactions" LogLineInformation_INCONSISTENT_RANGE_BOUNDS LogLineInformation_LogClassification = 140 // "range lower bound must be less than or equal to range upper bound" + LogLineInformation_VALUE_OUT_OF_RANGE LogLineInformation_LogClassification = 141 // "... out of range", "... field value out of range", "numeric field overflow" (for non-integer types; integers use INTEGER_OUT_OF_RANGE) + LogLineInformation_OBJECT_DOES_NOT_EXIST LogLineInformation_LogClassification = 142 // " ... does not exist" for object types without a dedicated classification (role, type, schema, index, collation, extension, ...); relations/columns/functions/operators use their own + LogLineInformation_ROW_LEVEL_SECURITY_VIOLATION LogLineInformation_LogClassification = 143 // "new row violates row-level security policy for table ...", "query would be affected by row-level security policy for table ..." (errcode 42501) + LogLineInformation_WITH_CHECK_OPTION_VIOLATION LogLineInformation_LogClassification = 144 // "new row violates check option for view ..." (errcode 44000) + LogLineInformation_CANNOT_MODIFY_VIEW LogLineInformation_LogClassification = 145 // "cannot insert into/update/delete from/merge into [column ... of] view ..." for non-updatable views (errcodes 55000, 0A000) + LogLineInformation_SQL_JSON_ERROR LogLineInformation_LogClassification = 146 // JSON / jsonpath / SQL-JSON processing errors (errcodes vary: 2203x SQL/JSON subclass, plus 22P02, 22023, 42601, 0A000, ...) + LogLineInformation_PARTITION_ERROR LogLineInformation_LogClassification = 147 // partitioning DDL/operation errors: invalid bounds/keys, overlaps, cannot attach/detach/merge/split, ... (errcodes vary: 42P16, 42P17, 0A000; runtime routing/constraint failures use CHECK_CONSTRAINT_VIOLATION, "X is [not] a partition[ed] ..." uses WRONG_OBJECT_TYPE) + LogLineInformation_OBJECT_ALREADY_EXISTS LogLineInformation_LogClassification = 148 // " ... already exists" for any object type (relation, type, column, constraint, function, ...) (duplicate_* errcodes: 42710, 42P07, 42701, 42723) + LogLineInformation_WRONG_OBJECT_TYPE LogLineInformation_LogClassification = 149 // operation attempted on the wrong kind of object: "\"...\" is [not] a[n] " (incl. partition[ed] forms), "ALTER action ... cannot be performed on relation ..." (mostly errcode 42809; partition variants also 42P17/0A000) // Collector internal events LogLineInformation_PGA_COLLECTOR_IDENTIFY LogLineInformation_LogClassification = 1000 // "pganalyze-collector-identify: server1" ) @@ -339,6 +349,7 @@ var ( 66: "AUTOANALYZE_COMPLETED", 67: "SKIPPING_VACUUM_LOCK_NOT_AVAILABLE", 68: "SKIPPING_ANALYZE_LOCK_NOT_AVAILABLE", + 69: "SKIPPING_MAINTENANCE_PERMISSION_DENIED", 70: "LOCK_ACQUIRED", 71: "LOCK_WAITING", 72: "LOCK_TIMEOUT", @@ -392,109 +403,128 @@ var ( 138: "COULD_NOT_SERIALIZE_REPEATABLE_READ", 139: "COULD_NOT_SERIALIZE_SERIALIZABLE", 140: "INCONSISTENT_RANGE_BOUNDS", + 141: "VALUE_OUT_OF_RANGE", + 142: "OBJECT_DOES_NOT_EXIST", + 143: "ROW_LEVEL_SECURITY_VIOLATION", + 144: "WITH_CHECK_OPTION_VIOLATION", + 145: "CANNOT_MODIFY_VIEW", + 146: "SQL_JSON_ERROR", + 147: "PARTITION_ERROR", + 148: "OBJECT_ALREADY_EXISTS", + 149: "WRONG_OBJECT_TYPE", 1000: "PGA_COLLECTOR_IDENTIFY", } LogLineInformation_LogClassification_value = map[string]int32{ - "UNKNOWN_LOG_CLASSIFICATION": 0, - "SERVER_CRASHED": 1, - "SERVER_START": 2, - "SERVER_START_RECOVERING": 3, - "SERVER_SHUTDOWN": 4, - "SERVER_OUT_OF_MEMORY": 5, - "SERVER_INVALID_CHECKSUM": 6, - "SERVER_TEMP_FILE_CREATED": 7, - "SERVER_MISC": 8, - "SERVER_RELOAD": 9, - "SERVER_PROCESS_EXITED": 10, - "SERVER_STATS_COLLECTOR_TIMEOUT": 11, - "CONNECTION_RECEIVED": 20, - "CONNECTION_AUTHORIZED": 21, - "CONNECTION_REJECTED": 22, - "CONNECTION_DISCONNECTED": 23, - "CONNECTION_CLIENT_FAILED_TO_CONNECT": 24, - "CONNECTION_LOST": 25, - "CONNECTION_LOST_OPEN_TX": 26, - "CONNECTION_TERMINATED": 27, - "OUT_OF_CONNECTIONS": 28, - "TOO_MANY_CONNECTIONS_ROLE": 29, - "COULD_NOT_ACCEPT_SSL_CONNECTION": 30, - "PROTOCOL_ERROR_UNSUPPORTED_VERSION": 31, - "PROTOCOL_ERROR_INCOMPLETE_MESSAGE": 32, - "TOO_MANY_CONNECTIONS_DATABASE": 33, - "CONNECTION_AUTHENTICATED": 34, - "CHECKPOINT_STARTING": 40, - "CHECKPOINT_COMPLETE": 41, - "CHECKPOINT_TOO_FREQUENT": 42, - "RESTARTPOINT_STARTING": 43, - "RESTARTPOINT_COMPLETE": 44, - "RESTARTPOINT_AT": 45, - "WAL_INVALID_RECORD_LENGTH": 50, - "WAL_REDO": 51, - "WAL_ARCHIVE_COMMAND_FAILED": 52, - "WAL_BASE_BACKUP_COMPLETE": 53, - "AUTOVACUUM_CANCEL": 60, - "TXID_WRAPAROUND_WARNING": 61, - "TXID_WRAPAROUND_ERROR": 62, - "AUTOVACUUM_LAUNCHER_STARTED": 63, - "AUTOVACUUM_LAUNCHER_SHUTTING_DOWN": 64, - "AUTOVACUUM_COMPLETED": 65, - "AUTOANALYZE_COMPLETED": 66, - "SKIPPING_VACUUM_LOCK_NOT_AVAILABLE": 67, - "SKIPPING_ANALYZE_LOCK_NOT_AVAILABLE": 68, - "LOCK_ACQUIRED": 70, - "LOCK_WAITING": 71, - "LOCK_TIMEOUT": 72, - "LOCK_DEADLOCK_DETECTED": 73, - "LOCK_DEADLOCK_AVOIDED": 74, - "STATEMENT_DURATION": 80, - "STATEMENT_CANCELED_TIMEOUT": 81, - "STATEMENT_CANCELED_USER": 82, - "STATEMENT_LOG": 83, - "STATEMENT_AUTO_EXPLAIN": 84, - "STANDBY_RESTORED_WAL_FROM_ARCHIVE": 90, - "STANDBY_STARTED_STREAMING": 91, - "STANDBY_STREAMING_INTERRUPTED": 92, - "STANDBY_STOPPED_STREAMING": 93, - "STANDBY_CONSISTENT_RECOVERY_STATE": 94, - "STANDBY_STATEMENT_CANCELED": 95, - "STANDBY_INVALID_TIMELINE": 96, - "UNIQUE_CONSTRAINT_VIOLATION": 100, - "FOREIGN_KEY_CONSTRAINT_VIOLATION": 101, - "NOT_NULL_CONSTRAINT_VIOLATION": 102, - "CHECK_CONSTRAINT_VIOLATION": 103, - "EXCLUSION_CONSTRAINT_VIOLATION": 104, - "SYNTAX_ERROR": 110, - "INVALID_INPUT_SYNTAX": 111, - "VALUE_TOO_LONG_FOR_TYPE": 112, - "INVALID_VALUE": 113, - "MALFORMED_ARRAY_LITERAL": 114, - "SUBQUERY_MISSING_ALIAS": 115, - "INSERT_TARGET_COLUMN_MISMATCH": 116, - "ANY_ALL_REQUIRES_ARRAY": 117, - "COLUMN_MISSING_FROM_GROUP_BY": 118, - "RELATION_DOES_NOT_EXIST": 119, - "COLUMN_DOES_NOT_EXIST": 120, - "OPERATOR_DOES_NOT_EXIST": 121, - "COLUMN_REFERENCE_AMBIGUOUS": 122, - "PERMISSION_DENIED": 123, - "TRANSACTION_IS_ABORTED": 124, - "ON_CONFLICT_NO_CONSTRAINT_MATCH": 125, - "ON_CONFLICT_ROW_AFFECTED_TWICE": 126, - "COLUMN_CANNOT_BE_CAST": 127, - "DIVISION_BY_ZERO": 128, - "CANNOT_DROP": 129, - "INTEGER_OUT_OF_RANGE": 130, - "INVALID_REGEXP": 131, - "PARAM_MISSING": 132, - "FUNCTION_DOES_NOT_EXIST": 133, - "NO_SUCH_SAVEPOINT": 134, - "UNTERMINATED_QUOTED_STRING": 135, - "UNTERMINATED_QUOTED_IDENTIFIER": 136, - "INVALID_BYTE_SEQUENCE": 137, - "COULD_NOT_SERIALIZE_REPEATABLE_READ": 138, - "COULD_NOT_SERIALIZE_SERIALIZABLE": 139, - "INCONSISTENT_RANGE_BOUNDS": 140, - "PGA_COLLECTOR_IDENTIFY": 1000, + "UNKNOWN_LOG_CLASSIFICATION": 0, + "SERVER_CRASHED": 1, + "SERVER_START": 2, + "SERVER_START_RECOVERING": 3, + "SERVER_SHUTDOWN": 4, + "SERVER_OUT_OF_MEMORY": 5, + "SERVER_INVALID_CHECKSUM": 6, + "SERVER_TEMP_FILE_CREATED": 7, + "SERVER_MISC": 8, + "SERVER_RELOAD": 9, + "SERVER_PROCESS_EXITED": 10, + "SERVER_STATS_COLLECTOR_TIMEOUT": 11, + "CONNECTION_RECEIVED": 20, + "CONNECTION_AUTHORIZED": 21, + "CONNECTION_REJECTED": 22, + "CONNECTION_DISCONNECTED": 23, + "CONNECTION_CLIENT_FAILED_TO_CONNECT": 24, + "CONNECTION_LOST": 25, + "CONNECTION_LOST_OPEN_TX": 26, + "CONNECTION_TERMINATED": 27, + "OUT_OF_CONNECTIONS": 28, + "TOO_MANY_CONNECTIONS_ROLE": 29, + "COULD_NOT_ACCEPT_SSL_CONNECTION": 30, + "PROTOCOL_ERROR_UNSUPPORTED_VERSION": 31, + "PROTOCOL_ERROR_INCOMPLETE_MESSAGE": 32, + "TOO_MANY_CONNECTIONS_DATABASE": 33, + "CONNECTION_AUTHENTICATED": 34, + "CHECKPOINT_STARTING": 40, + "CHECKPOINT_COMPLETE": 41, + "CHECKPOINT_TOO_FREQUENT": 42, + "RESTARTPOINT_STARTING": 43, + "RESTARTPOINT_COMPLETE": 44, + "RESTARTPOINT_AT": 45, + "WAL_INVALID_RECORD_LENGTH": 50, + "WAL_REDO": 51, + "WAL_ARCHIVE_COMMAND_FAILED": 52, + "WAL_BASE_BACKUP_COMPLETE": 53, + "AUTOVACUUM_CANCEL": 60, + "TXID_WRAPAROUND_WARNING": 61, + "TXID_WRAPAROUND_ERROR": 62, + "AUTOVACUUM_LAUNCHER_STARTED": 63, + "AUTOVACUUM_LAUNCHER_SHUTTING_DOWN": 64, + "AUTOVACUUM_COMPLETED": 65, + "AUTOANALYZE_COMPLETED": 66, + "SKIPPING_VACUUM_LOCK_NOT_AVAILABLE": 67, + "SKIPPING_ANALYZE_LOCK_NOT_AVAILABLE": 68, + "SKIPPING_MAINTENANCE_PERMISSION_DENIED": 69, + "LOCK_ACQUIRED": 70, + "LOCK_WAITING": 71, + "LOCK_TIMEOUT": 72, + "LOCK_DEADLOCK_DETECTED": 73, + "LOCK_DEADLOCK_AVOIDED": 74, + "STATEMENT_DURATION": 80, + "STATEMENT_CANCELED_TIMEOUT": 81, + "STATEMENT_CANCELED_USER": 82, + "STATEMENT_LOG": 83, + "STATEMENT_AUTO_EXPLAIN": 84, + "STANDBY_RESTORED_WAL_FROM_ARCHIVE": 90, + "STANDBY_STARTED_STREAMING": 91, + "STANDBY_STREAMING_INTERRUPTED": 92, + "STANDBY_STOPPED_STREAMING": 93, + "STANDBY_CONSISTENT_RECOVERY_STATE": 94, + "STANDBY_STATEMENT_CANCELED": 95, + "STANDBY_INVALID_TIMELINE": 96, + "UNIQUE_CONSTRAINT_VIOLATION": 100, + "FOREIGN_KEY_CONSTRAINT_VIOLATION": 101, + "NOT_NULL_CONSTRAINT_VIOLATION": 102, + "CHECK_CONSTRAINT_VIOLATION": 103, + "EXCLUSION_CONSTRAINT_VIOLATION": 104, + "SYNTAX_ERROR": 110, + "INVALID_INPUT_SYNTAX": 111, + "VALUE_TOO_LONG_FOR_TYPE": 112, + "INVALID_VALUE": 113, + "MALFORMED_ARRAY_LITERAL": 114, + "SUBQUERY_MISSING_ALIAS": 115, + "INSERT_TARGET_COLUMN_MISMATCH": 116, + "ANY_ALL_REQUIRES_ARRAY": 117, + "COLUMN_MISSING_FROM_GROUP_BY": 118, + "RELATION_DOES_NOT_EXIST": 119, + "COLUMN_DOES_NOT_EXIST": 120, + "OPERATOR_DOES_NOT_EXIST": 121, + "COLUMN_REFERENCE_AMBIGUOUS": 122, + "PERMISSION_DENIED": 123, + "TRANSACTION_IS_ABORTED": 124, + "ON_CONFLICT_NO_CONSTRAINT_MATCH": 125, + "ON_CONFLICT_ROW_AFFECTED_TWICE": 126, + "COLUMN_CANNOT_BE_CAST": 127, + "DIVISION_BY_ZERO": 128, + "CANNOT_DROP": 129, + "INTEGER_OUT_OF_RANGE": 130, + "INVALID_REGEXP": 131, + "PARAM_MISSING": 132, + "FUNCTION_DOES_NOT_EXIST": 133, + "NO_SUCH_SAVEPOINT": 134, + "UNTERMINATED_QUOTED_STRING": 135, + "UNTERMINATED_QUOTED_IDENTIFIER": 136, + "INVALID_BYTE_SEQUENCE": 137, + "COULD_NOT_SERIALIZE_REPEATABLE_READ": 138, + "COULD_NOT_SERIALIZE_SERIALIZABLE": 139, + "INCONSISTENT_RANGE_BOUNDS": 140, + "VALUE_OUT_OF_RANGE": 141, + "OBJECT_DOES_NOT_EXIST": 142, + "ROW_LEVEL_SECURITY_VIOLATION": 143, + "WITH_CHECK_OPTION_VIOLATION": 144, + "CANNOT_MODIFY_VIEW": 145, + "SQL_JSON_ERROR": 146, + "PARTITION_ERROR": 147, + "OBJECT_ALREADY_EXISTS": 148, + "WRONG_OBJECT_TYPE": 149, + "PGA_COLLECTOR_IDENTIFY": 1000, } ) @@ -1160,7 +1190,7 @@ var file_compact_log_snapshot_proto_rawDesc = []byte{ 0x45, 0x43, 0x52, 0x45, 0x54, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x4f, 0x50, 0x53, 0x5f, 0x4c, 0x4f, 0x47, 0x5f, 0x53, 0x45, 0x43, 0x52, 0x45, 0x54, 0x10, 0x05, 0x12, 0x1b, 0x0a, 0x17, 0x55, 0x4e, 0x49, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x46, 0x49, 0x45, 0x44, 0x5f, 0x4c, 0x4f, 0x47, 0x5f, - 0x53, 0x45, 0x43, 0x52, 0x45, 0x54, 0x10, 0x06, 0x22, 0xf6, 0x1e, 0x0a, 0x12, 0x4c, 0x6f, 0x67, + 0x53, 0x45, 0x43, 0x52, 0x45, 0x54, 0x10, 0x06, 0x22, 0x94, 0x21, 0x0a, 0x12, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x0c, 0x6c, 0x6f, 0x67, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x69, 0x64, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6c, 0x6f, 0x67, 0x46, 0x69, 0x6c, 0x65, 0x49, 0x64, @@ -1226,7 +1256,7 @@ var file_compact_log_snapshot_proto_rawDesc = []byte{ 0x58, 0x54, 0x10, 0x0b, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x10, 0x0c, 0x12, 0x09, 0x0a, 0x05, 0x51, 0x55, 0x45, 0x52, 0x59, 0x10, 0x0d, 0x12, 0x0c, 0x0a, 0x08, 0x4c, 0x4f, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x0e, 0x12, 0x0d, 0x0a, 0x09, - 0x42, 0x41, 0x43, 0x4b, 0x54, 0x52, 0x41, 0x43, 0x45, 0x10, 0x0f, 0x22, 0xd3, 0x16, 0x0a, 0x11, + 0x42, 0x41, 0x43, 0x4b, 0x54, 0x52, 0x41, 0x43, 0x45, 0x10, 0x0f, 0x22, 0xf1, 0x18, 0x0a, 0x11, 0x4c, 0x6f, 0x67, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1e, 0x0a, 0x1a, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x4c, 0x4f, 0x47, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, @@ -1310,161 +1340,179 @@ var file_compact_log_snapshot_proto_rawDesc = []byte{ 0x41, 0x42, 0x4c, 0x45, 0x10, 0x43, 0x12, 0x27, 0x0a, 0x23, 0x53, 0x4b, 0x49, 0x50, 0x50, 0x49, 0x4e, 0x47, 0x5f, 0x41, 0x4e, 0x41, 0x4c, 0x59, 0x5a, 0x45, 0x5f, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x44, 0x12, - 0x11, 0x0a, 0x0d, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x41, 0x43, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, - 0x10, 0x46, 0x12, 0x10, 0x0a, 0x0c, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x57, 0x41, 0x49, 0x54, 0x49, - 0x4e, 0x47, 0x10, 0x47, 0x12, 0x10, 0x0a, 0x0c, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x54, 0x49, 0x4d, - 0x45, 0x4f, 0x55, 0x54, 0x10, 0x48, 0x12, 0x1a, 0x0a, 0x16, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x44, - 0x45, 0x41, 0x44, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x44, 0x45, 0x54, 0x45, 0x43, 0x54, 0x45, 0x44, - 0x10, 0x49, 0x12, 0x19, 0x0a, 0x15, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x44, 0x45, 0x41, 0x44, 0x4c, - 0x4f, 0x43, 0x4b, 0x5f, 0x41, 0x56, 0x4f, 0x49, 0x44, 0x45, 0x44, 0x10, 0x4a, 0x12, 0x16, 0x0a, - 0x12, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x44, 0x55, 0x52, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x10, 0x50, 0x12, 0x1e, 0x0a, 0x1a, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, - 0x4e, 0x54, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x5f, 0x54, 0x49, 0x4d, 0x45, - 0x4f, 0x55, 0x54, 0x10, 0x51, 0x12, 0x1b, 0x0a, 0x17, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, - 0x4e, 0x54, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x5f, 0x55, 0x53, 0x45, 0x52, - 0x10, 0x52, 0x12, 0x11, 0x0a, 0x0d, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, - 0x4c, 0x4f, 0x47, 0x10, 0x53, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, - 0x4e, 0x54, 0x5f, 0x41, 0x55, 0x54, 0x4f, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x10, - 0x54, 0x12, 0x25, 0x0a, 0x21, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, 0x59, 0x5f, 0x52, 0x45, 0x53, - 0x54, 0x4f, 0x52, 0x45, 0x44, 0x5f, 0x57, 0x41, 0x4c, 0x5f, 0x46, 0x52, 0x4f, 0x4d, 0x5f, 0x41, - 0x52, 0x43, 0x48, 0x49, 0x56, 0x45, 0x10, 0x5a, 0x12, 0x1d, 0x0a, 0x19, 0x53, 0x54, 0x41, 0x4e, - 0x44, 0x42, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x52, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x52, 0x45, - 0x41, 0x4d, 0x49, 0x4e, 0x47, 0x10, 0x5b, 0x12, 0x21, 0x0a, 0x1d, 0x53, 0x54, 0x41, 0x4e, 0x44, - 0x42, 0x59, 0x5f, 0x53, 0x54, 0x52, 0x45, 0x41, 0x4d, 0x49, 0x4e, 0x47, 0x5f, 0x49, 0x4e, 0x54, - 0x45, 0x52, 0x52, 0x55, 0x50, 0x54, 0x45, 0x44, 0x10, 0x5c, 0x12, 0x1d, 0x0a, 0x19, 0x53, 0x54, - 0x41, 0x4e, 0x44, 0x42, 0x59, 0x5f, 0x53, 0x54, 0x4f, 0x50, 0x50, 0x45, 0x44, 0x5f, 0x53, 0x54, - 0x52, 0x45, 0x41, 0x4d, 0x49, 0x4e, 0x47, 0x10, 0x5d, 0x12, 0x25, 0x0a, 0x21, 0x53, 0x54, 0x41, - 0x4e, 0x44, 0x42, 0x59, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x54, 0x5f, - 0x52, 0x45, 0x43, 0x4f, 0x56, 0x45, 0x52, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x10, 0x5e, - 0x12, 0x1e, 0x0a, 0x1a, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x54, - 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x10, 0x5f, - 0x12, 0x1c, 0x0a, 0x18, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, 0x59, 0x5f, 0x49, 0x4e, 0x56, 0x41, - 0x4c, 0x49, 0x44, 0x5f, 0x54, 0x49, 0x4d, 0x45, 0x4c, 0x49, 0x4e, 0x45, 0x10, 0x60, 0x12, 0x1f, - 0x0a, 0x1b, 0x55, 0x4e, 0x49, 0x51, 0x55, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, - 0x49, 0x4e, 0x54, 0x5f, 0x56, 0x49, 0x4f, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x64, 0x12, - 0x24, 0x0a, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x43, - 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, 0x5f, 0x56, 0x49, 0x4f, 0x4c, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x10, 0x65, 0x12, 0x21, 0x0a, 0x1d, 0x4e, 0x4f, 0x54, 0x5f, 0x4e, 0x55, 0x4c, - 0x4c, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, 0x5f, 0x56, 0x49, 0x4f, - 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x66, 0x12, 0x1e, 0x0a, 0x1a, 0x43, 0x48, 0x45, 0x43, - 0x4b, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, 0x5f, 0x56, 0x49, 0x4f, - 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x67, 0x12, 0x22, 0x0a, 0x1e, 0x45, 0x58, 0x43, 0x4c, - 0x55, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, - 0x5f, 0x56, 0x49, 0x4f, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x68, 0x12, 0x10, 0x0a, 0x0c, - 0x53, 0x59, 0x4e, 0x54, 0x41, 0x58, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x6e, 0x12, 0x18, - 0x0a, 0x14, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x5f, - 0x53, 0x59, 0x4e, 0x54, 0x41, 0x58, 0x10, 0x6f, 0x12, 0x1b, 0x0a, 0x17, 0x56, 0x41, 0x4c, 0x55, - 0x45, 0x5f, 0x54, 0x4f, 0x4f, 0x5f, 0x4c, 0x4f, 0x4e, 0x47, 0x5f, 0x46, 0x4f, 0x52, 0x5f, 0x54, - 0x59, 0x50, 0x45, 0x10, 0x70, 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, - 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x10, 0x71, 0x12, 0x1b, 0x0a, 0x17, 0x4d, 0x41, 0x4c, 0x46, - 0x4f, 0x52, 0x4d, 0x45, 0x44, 0x5f, 0x41, 0x52, 0x52, 0x41, 0x59, 0x5f, 0x4c, 0x49, 0x54, 0x45, - 0x52, 0x41, 0x4c, 0x10, 0x72, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x55, 0x42, 0x51, 0x55, 0x45, 0x52, - 0x59, 0x5f, 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4e, 0x47, 0x5f, 0x41, 0x4c, 0x49, 0x41, 0x53, 0x10, - 0x73, 0x12, 0x21, 0x0a, 0x1d, 0x49, 0x4e, 0x53, 0x45, 0x52, 0x54, 0x5f, 0x54, 0x41, 0x52, 0x47, - 0x45, 0x54, 0x5f, 0x43, 0x4f, 0x4c, 0x55, 0x4d, 0x4e, 0x5f, 0x4d, 0x49, 0x53, 0x4d, 0x41, 0x54, - 0x43, 0x48, 0x10, 0x74, 0x12, 0x1a, 0x0a, 0x16, 0x41, 0x4e, 0x59, 0x5f, 0x41, 0x4c, 0x4c, 0x5f, - 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45, 0x53, 0x5f, 0x41, 0x52, 0x52, 0x41, 0x59, 0x10, 0x75, - 0x12, 0x20, 0x0a, 0x1c, 0x43, 0x4f, 0x4c, 0x55, 0x4d, 0x4e, 0x5f, 0x4d, 0x49, 0x53, 0x53, 0x49, - 0x4e, 0x47, 0x5f, 0x46, 0x52, 0x4f, 0x4d, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, - 0x10, 0x76, 0x12, 0x1b, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, - 0x4f, 0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x10, 0x77, 0x12, - 0x19, 0x0a, 0x15, 0x43, 0x4f, 0x4c, 0x55, 0x4d, 0x4e, 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, 0x4e, - 0x4f, 0x54, 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x10, 0x78, 0x12, 0x1b, 0x0a, 0x17, 0x4f, 0x50, - 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, - 0x45, 0x58, 0x49, 0x53, 0x54, 0x10, 0x79, 0x12, 0x1e, 0x0a, 0x1a, 0x43, 0x4f, 0x4c, 0x55, 0x4d, - 0x4e, 0x5f, 0x52, 0x45, 0x46, 0x45, 0x52, 0x45, 0x4e, 0x43, 0x45, 0x5f, 0x41, 0x4d, 0x42, 0x49, - 0x47, 0x55, 0x4f, 0x55, 0x53, 0x10, 0x7a, 0x12, 0x15, 0x0a, 0x11, 0x50, 0x45, 0x52, 0x4d, 0x49, - 0x53, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x4e, 0x49, 0x45, 0x44, 0x10, 0x7b, 0x12, 0x1a, - 0x0a, 0x16, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x49, 0x53, - 0x5f, 0x41, 0x42, 0x4f, 0x52, 0x54, 0x45, 0x44, 0x10, 0x7c, 0x12, 0x23, 0x0a, 0x1f, 0x4f, 0x4e, - 0x5f, 0x43, 0x4f, 0x4e, 0x46, 0x4c, 0x49, 0x43, 0x54, 0x5f, 0x4e, 0x4f, 0x5f, 0x43, 0x4f, 0x4e, - 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, 0x5f, 0x4d, 0x41, 0x54, 0x43, 0x48, 0x10, 0x7d, 0x12, - 0x22, 0x0a, 0x1e, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4e, 0x46, 0x4c, 0x49, 0x43, 0x54, 0x5f, 0x52, - 0x4f, 0x57, 0x5f, 0x41, 0x46, 0x46, 0x45, 0x43, 0x54, 0x45, 0x44, 0x5f, 0x54, 0x57, 0x49, 0x43, - 0x45, 0x10, 0x7e, 0x12, 0x19, 0x0a, 0x15, 0x43, 0x4f, 0x4c, 0x55, 0x4d, 0x4e, 0x5f, 0x43, 0x41, - 0x4e, 0x4e, 0x4f, 0x54, 0x5f, 0x42, 0x45, 0x5f, 0x43, 0x41, 0x53, 0x54, 0x10, 0x7f, 0x12, 0x15, - 0x0a, 0x10, 0x44, 0x49, 0x56, 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x42, 0x59, 0x5f, 0x5a, 0x45, - 0x52, 0x4f, 0x10, 0x80, 0x01, 0x12, 0x10, 0x0a, 0x0b, 0x43, 0x41, 0x4e, 0x4e, 0x4f, 0x54, 0x5f, - 0x44, 0x52, 0x4f, 0x50, 0x10, 0x81, 0x01, 0x12, 0x19, 0x0a, 0x14, 0x49, 0x4e, 0x54, 0x45, 0x47, - 0x45, 0x52, 0x5f, 0x4f, 0x55, 0x54, 0x5f, 0x4f, 0x46, 0x5f, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x10, - 0x82, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x52, 0x45, - 0x47, 0x45, 0x58, 0x50, 0x10, 0x83, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x50, 0x41, 0x52, 0x41, 0x4d, - 0x5f, 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4e, 0x47, 0x10, 0x84, 0x01, 0x12, 0x1c, 0x0a, 0x17, 0x46, - 0x55, 0x4e, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, - 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x10, 0x85, 0x01, 0x12, 0x16, 0x0a, 0x11, 0x4e, 0x4f, 0x5f, - 0x53, 0x55, 0x43, 0x48, 0x5f, 0x53, 0x41, 0x56, 0x45, 0x50, 0x4f, 0x49, 0x4e, 0x54, 0x10, 0x86, - 0x01, 0x12, 0x1f, 0x0a, 0x1a, 0x55, 0x4e, 0x54, 0x45, 0x52, 0x4d, 0x49, 0x4e, 0x41, 0x54, 0x45, - 0x44, 0x5f, 0x51, 0x55, 0x4f, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, - 0x87, 0x01, 0x12, 0x23, 0x0a, 0x1e, 0x55, 0x4e, 0x54, 0x45, 0x52, 0x4d, 0x49, 0x4e, 0x41, 0x54, - 0x45, 0x44, 0x5f, 0x51, 0x55, 0x4f, 0x54, 0x45, 0x44, 0x5f, 0x49, 0x44, 0x45, 0x4e, 0x54, 0x49, - 0x46, 0x49, 0x45, 0x52, 0x10, 0x88, 0x01, 0x12, 0x1a, 0x0a, 0x15, 0x49, 0x4e, 0x56, 0x41, 0x4c, - 0x49, 0x44, 0x5f, 0x42, 0x59, 0x54, 0x45, 0x5f, 0x53, 0x45, 0x51, 0x55, 0x45, 0x4e, 0x43, 0x45, - 0x10, 0x89, 0x01, 0x12, 0x28, 0x0a, 0x23, 0x43, 0x4f, 0x55, 0x4c, 0x44, 0x5f, 0x4e, 0x4f, 0x54, - 0x5f, 0x53, 0x45, 0x52, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x45, 0x5f, 0x52, 0x45, 0x50, 0x45, 0x41, - 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x10, 0x8a, 0x01, 0x12, 0x25, 0x0a, - 0x20, 0x43, 0x4f, 0x55, 0x4c, 0x44, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x53, 0x45, 0x52, 0x49, 0x41, - 0x4c, 0x49, 0x5a, 0x45, 0x5f, 0x53, 0x45, 0x52, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x41, 0x42, 0x4c, - 0x45, 0x10, 0x8b, 0x01, 0x12, 0x1e, 0x0a, 0x19, 0x49, 0x4e, 0x43, 0x4f, 0x4e, 0x53, 0x49, 0x53, - 0x54, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x5f, 0x42, 0x4f, 0x55, 0x4e, 0x44, - 0x53, 0x10, 0x8c, 0x01, 0x12, 0x1b, 0x0a, 0x16, 0x50, 0x47, 0x41, 0x5f, 0x43, 0x4f, 0x4c, 0x4c, - 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, 0x49, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x46, 0x59, 0x10, 0xe8, - 0x07, 0x22, 0xc3, 0x06, 0x0a, 0x0b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x61, 0x6d, 0x70, 0x6c, - 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x78, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x71, 0x75, 0x65, 0x72, 0x79, 0x49, 0x64, 0x78, 0x12, 0x3b, - 0x0a, 0x0b, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, - 0x0a, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x41, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x72, - 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6d, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, - 0x09, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x71, 0x75, 0x65, 0x72, 0x79, 0x54, 0x65, 0x78, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x61, 0x72, - 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x5f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x18, 0x05, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, - 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x12, 0x3f, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, - 0x74, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x70, 0x67, 0x61, - 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, - 0x2e, 0x4e, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0a, 0x70, 0x61, 0x72, - 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x22, 0x0a, 0x0d, 0x6c, 0x6f, 0x67, 0x5f, 0x6c, - 0x69, 0x6e, 0x65, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, - 0x6c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x55, 0x75, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x68, - 0x61, 0x73, 0x5f, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x0a, 0x68, 0x61, 0x73, 0x45, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x12, 0x25, 0x0a, 0x0e, - 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x15, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x4f, 0x75, 0x74, - 0x70, 0x75, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x5f, 0x65, - 0x72, 0x72, 0x6f, 0x72, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x78, 0x70, 0x6c, - 0x61, 0x69, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x55, 0x0a, 0x0e, 0x65, 0x78, 0x70, 0x6c, - 0x61, 0x69, 0x6e, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0e, - 0x32, 0x2e, 0x2e, 0x70, 0x67, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x2e, 0x63, 0x6f, 0x6c, - 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x61, 0x6d, 0x70, - 0x6c, 0x65, 0x2e, 0x45, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, - 0x52, 0x0d, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, - 0x55, 0x0a, 0x0e, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2e, 0x2e, 0x70, 0x67, 0x61, 0x6e, 0x61, 0x6c, - 0x79, 0x7a, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x45, 0x78, 0x70, 0x6c, 0x61, 0x69, - 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x0d, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, - 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, - 0x69, 0x7a, 0x65, 0x64, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x6e, 0x6f, 0x72, 0x6d, - 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x41, 0x0a, 0x0d, 0x45, 0x78, 0x70, 0x6c, 0x61, 0x69, - 0x6e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x17, 0x0a, 0x13, 0x54, 0x45, 0x58, 0x54, 0x5f, - 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x10, 0x00, - 0x12, 0x17, 0x0a, 0x13, 0x4a, 0x53, 0x4f, 0x4e, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, - 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x10, 0x01, 0x22, 0x8b, 0x01, 0x0a, 0x0d, 0x45, 0x78, - 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x20, 0x0a, 0x1c, 0x53, - 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x4c, 0x4f, 0x47, 0x5f, 0x45, 0x58, 0x50, - 0x4c, 0x41, 0x49, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, 0x00, 0x12, 0x1f, 0x0a, - 0x1b, 0x41, 0x55, 0x54, 0x4f, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x5f, 0x45, 0x58, - 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, 0x01, 0x12, 0x1b, - 0x0a, 0x17, 0x45, 0x58, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, - 0x49, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, 0x02, 0x12, 0x1a, 0x0a, 0x16, 0x47, - 0x45, 0x4e, 0x45, 0x52, 0x49, 0x43, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x5f, 0x53, - 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, 0x03, 0x42, 0x3b, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, - 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x67, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x2f, - 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, - 0x2f, 0x70, 0x67, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, - 0x63, 0x74, 0x6f, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x2a, 0x0a, 0x26, 0x53, 0x4b, 0x49, 0x50, 0x50, 0x49, 0x4e, 0x47, 0x5f, 0x4d, 0x41, 0x49, 0x4e, + 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x50, 0x45, 0x52, 0x4d, 0x49, 0x53, 0x53, 0x49, + 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x4e, 0x49, 0x45, 0x44, 0x10, 0x45, 0x12, 0x11, 0x0a, 0x0d, 0x4c, + 0x4f, 0x43, 0x4b, 0x5f, 0x41, 0x43, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x10, 0x46, 0x12, 0x10, + 0x0a, 0x0c, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x57, 0x41, 0x49, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x47, + 0x12, 0x10, 0x0a, 0x0c, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x54, 0x49, 0x4d, 0x45, 0x4f, 0x55, 0x54, + 0x10, 0x48, 0x12, 0x1a, 0x0a, 0x16, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x44, 0x45, 0x41, 0x44, 0x4c, + 0x4f, 0x43, 0x4b, 0x5f, 0x44, 0x45, 0x54, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x49, 0x12, 0x19, + 0x0a, 0x15, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x44, 0x45, 0x41, 0x44, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, + 0x41, 0x56, 0x4f, 0x49, 0x44, 0x45, 0x44, 0x10, 0x4a, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x54, 0x41, + 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x44, 0x55, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, + 0x50, 0x12, 0x1e, 0x0a, 0x1a, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x43, + 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x5f, 0x54, 0x49, 0x4d, 0x45, 0x4f, 0x55, 0x54, 0x10, + 0x51, 0x12, 0x1b, 0x0a, 0x17, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x43, + 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x52, 0x12, 0x11, + 0x0a, 0x0d, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x4c, 0x4f, 0x47, 0x10, + 0x53, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x41, + 0x55, 0x54, 0x4f, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x10, 0x54, 0x12, 0x25, 0x0a, + 0x21, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, 0x59, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x4f, 0x52, 0x45, + 0x44, 0x5f, 0x57, 0x41, 0x4c, 0x5f, 0x46, 0x52, 0x4f, 0x4d, 0x5f, 0x41, 0x52, 0x43, 0x48, 0x49, + 0x56, 0x45, 0x10, 0x5a, 0x12, 0x1d, 0x0a, 0x19, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, 0x59, 0x5f, + 0x53, 0x54, 0x41, 0x52, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x52, 0x45, 0x41, 0x4d, 0x49, 0x4e, + 0x47, 0x10, 0x5b, 0x12, 0x21, 0x0a, 0x1d, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, 0x59, 0x5f, 0x53, + 0x54, 0x52, 0x45, 0x41, 0x4d, 0x49, 0x4e, 0x47, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x52, 0x55, + 0x50, 0x54, 0x45, 0x44, 0x10, 0x5c, 0x12, 0x1d, 0x0a, 0x19, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, + 0x59, 0x5f, 0x53, 0x54, 0x4f, 0x50, 0x50, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x52, 0x45, 0x41, 0x4d, + 0x49, 0x4e, 0x47, 0x10, 0x5d, 0x12, 0x25, 0x0a, 0x21, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, 0x59, + 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x45, 0x43, 0x4f, + 0x56, 0x45, 0x52, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x10, 0x5e, 0x12, 0x1e, 0x0a, 0x1a, + 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, + 0x54, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x10, 0x5f, 0x12, 0x1c, 0x0a, 0x18, + 0x53, 0x54, 0x41, 0x4e, 0x44, 0x42, 0x59, 0x5f, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, + 0x54, 0x49, 0x4d, 0x45, 0x4c, 0x49, 0x4e, 0x45, 0x10, 0x60, 0x12, 0x1f, 0x0a, 0x1b, 0x55, 0x4e, + 0x49, 0x51, 0x55, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, 0x5f, + 0x56, 0x49, 0x4f, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x64, 0x12, 0x24, 0x0a, 0x20, 0x46, + 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x54, + 0x52, 0x41, 0x49, 0x4e, 0x54, 0x5f, 0x56, 0x49, 0x4f, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, + 0x65, 0x12, 0x21, 0x0a, 0x1d, 0x4e, 0x4f, 0x54, 0x5f, 0x4e, 0x55, 0x4c, 0x4c, 0x5f, 0x43, 0x4f, + 0x4e, 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, 0x5f, 0x56, 0x49, 0x4f, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x10, 0x66, 0x12, 0x1e, 0x0a, 0x1a, 0x43, 0x48, 0x45, 0x43, 0x4b, 0x5f, 0x43, 0x4f, + 0x4e, 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, 0x5f, 0x56, 0x49, 0x4f, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x10, 0x67, 0x12, 0x22, 0x0a, 0x1e, 0x45, 0x58, 0x43, 0x4c, 0x55, 0x53, 0x49, 0x4f, + 0x4e, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, 0x5f, 0x56, 0x49, 0x4f, + 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x68, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x59, 0x4e, 0x54, + 0x41, 0x58, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x6e, 0x12, 0x18, 0x0a, 0x14, 0x49, 0x4e, + 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x5f, 0x53, 0x59, 0x4e, 0x54, + 0x41, 0x58, 0x10, 0x6f, 0x12, 0x1b, 0x0a, 0x17, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x54, 0x4f, + 0x4f, 0x5f, 0x4c, 0x4f, 0x4e, 0x47, 0x5f, 0x46, 0x4f, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, + 0x70, 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x56, 0x41, 0x4c, + 0x55, 0x45, 0x10, 0x71, 0x12, 0x1b, 0x0a, 0x17, 0x4d, 0x41, 0x4c, 0x46, 0x4f, 0x52, 0x4d, 0x45, + 0x44, 0x5f, 0x41, 0x52, 0x52, 0x41, 0x59, 0x5f, 0x4c, 0x49, 0x54, 0x45, 0x52, 0x41, 0x4c, 0x10, + 0x72, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x55, 0x42, 0x51, 0x55, 0x45, 0x52, 0x59, 0x5f, 0x4d, 0x49, + 0x53, 0x53, 0x49, 0x4e, 0x47, 0x5f, 0x41, 0x4c, 0x49, 0x41, 0x53, 0x10, 0x73, 0x12, 0x21, 0x0a, + 0x1d, 0x49, 0x4e, 0x53, 0x45, 0x52, 0x54, 0x5f, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x43, + 0x4f, 0x4c, 0x55, 0x4d, 0x4e, 0x5f, 0x4d, 0x49, 0x53, 0x4d, 0x41, 0x54, 0x43, 0x48, 0x10, 0x74, + 0x12, 0x1a, 0x0a, 0x16, 0x41, 0x4e, 0x59, 0x5f, 0x41, 0x4c, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, + 0x49, 0x52, 0x45, 0x53, 0x5f, 0x41, 0x52, 0x52, 0x41, 0x59, 0x10, 0x75, 0x12, 0x20, 0x0a, 0x1c, + 0x43, 0x4f, 0x4c, 0x55, 0x4d, 0x4e, 0x5f, 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4e, 0x47, 0x5f, 0x46, + 0x52, 0x4f, 0x4d, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x10, 0x76, 0x12, 0x1b, + 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, + 0x4e, 0x4f, 0x54, 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x10, 0x77, 0x12, 0x19, 0x0a, 0x15, 0x43, + 0x4f, 0x4c, 0x55, 0x4d, 0x4e, 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x45, + 0x58, 0x49, 0x53, 0x54, 0x10, 0x78, 0x12, 0x1b, 0x0a, 0x17, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, + 0x4f, 0x52, 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x45, 0x58, 0x49, 0x53, + 0x54, 0x10, 0x79, 0x12, 0x1e, 0x0a, 0x1a, 0x43, 0x4f, 0x4c, 0x55, 0x4d, 0x4e, 0x5f, 0x52, 0x45, + 0x46, 0x45, 0x52, 0x45, 0x4e, 0x43, 0x45, 0x5f, 0x41, 0x4d, 0x42, 0x49, 0x47, 0x55, 0x4f, 0x55, + 0x53, 0x10, 0x7a, 0x12, 0x15, 0x0a, 0x11, 0x50, 0x45, 0x52, 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4f, + 0x4e, 0x5f, 0x44, 0x45, 0x4e, 0x49, 0x45, 0x44, 0x10, 0x7b, 0x12, 0x1a, 0x0a, 0x16, 0x54, 0x52, + 0x41, 0x4e, 0x53, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x49, 0x53, 0x5f, 0x41, 0x42, 0x4f, + 0x52, 0x54, 0x45, 0x44, 0x10, 0x7c, 0x12, 0x23, 0x0a, 0x1f, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4e, + 0x46, 0x4c, 0x49, 0x43, 0x54, 0x5f, 0x4e, 0x4f, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, + 0x49, 0x4e, 0x54, 0x5f, 0x4d, 0x41, 0x54, 0x43, 0x48, 0x10, 0x7d, 0x12, 0x22, 0x0a, 0x1e, 0x4f, + 0x4e, 0x5f, 0x43, 0x4f, 0x4e, 0x46, 0x4c, 0x49, 0x43, 0x54, 0x5f, 0x52, 0x4f, 0x57, 0x5f, 0x41, + 0x46, 0x46, 0x45, 0x43, 0x54, 0x45, 0x44, 0x5f, 0x54, 0x57, 0x49, 0x43, 0x45, 0x10, 0x7e, 0x12, + 0x19, 0x0a, 0x15, 0x43, 0x4f, 0x4c, 0x55, 0x4d, 0x4e, 0x5f, 0x43, 0x41, 0x4e, 0x4e, 0x4f, 0x54, + 0x5f, 0x42, 0x45, 0x5f, 0x43, 0x41, 0x53, 0x54, 0x10, 0x7f, 0x12, 0x15, 0x0a, 0x10, 0x44, 0x49, + 0x56, 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x42, 0x59, 0x5f, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x80, + 0x01, 0x12, 0x10, 0x0a, 0x0b, 0x43, 0x41, 0x4e, 0x4e, 0x4f, 0x54, 0x5f, 0x44, 0x52, 0x4f, 0x50, + 0x10, 0x81, 0x01, 0x12, 0x19, 0x0a, 0x14, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x5f, 0x4f, + 0x55, 0x54, 0x5f, 0x4f, 0x46, 0x5f, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x10, 0x82, 0x01, 0x12, 0x13, + 0x0a, 0x0e, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x52, 0x45, 0x47, 0x45, 0x58, 0x50, + 0x10, 0x83, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x4d, 0x49, 0x53, + 0x53, 0x49, 0x4e, 0x47, 0x10, 0x84, 0x01, 0x12, 0x1c, 0x0a, 0x17, 0x46, 0x55, 0x4e, 0x43, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x45, 0x58, 0x49, + 0x53, 0x54, 0x10, 0x85, 0x01, 0x12, 0x16, 0x0a, 0x11, 0x4e, 0x4f, 0x5f, 0x53, 0x55, 0x43, 0x48, + 0x5f, 0x53, 0x41, 0x56, 0x45, 0x50, 0x4f, 0x49, 0x4e, 0x54, 0x10, 0x86, 0x01, 0x12, 0x1f, 0x0a, + 0x1a, 0x55, 0x4e, 0x54, 0x45, 0x52, 0x4d, 0x49, 0x4e, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x51, 0x55, + 0x4f, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x87, 0x01, 0x12, 0x23, + 0x0a, 0x1e, 0x55, 0x4e, 0x54, 0x45, 0x52, 0x4d, 0x49, 0x4e, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x51, + 0x55, 0x4f, 0x54, 0x45, 0x44, 0x5f, 0x49, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x46, 0x49, 0x45, 0x52, + 0x10, 0x88, 0x01, 0x12, 0x1a, 0x0a, 0x15, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x42, + 0x59, 0x54, 0x45, 0x5f, 0x53, 0x45, 0x51, 0x55, 0x45, 0x4e, 0x43, 0x45, 0x10, 0x89, 0x01, 0x12, + 0x28, 0x0a, 0x23, 0x43, 0x4f, 0x55, 0x4c, 0x44, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x53, 0x45, 0x52, + 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x45, 0x5f, 0x52, 0x45, 0x50, 0x45, 0x41, 0x54, 0x41, 0x42, 0x4c, + 0x45, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x10, 0x8a, 0x01, 0x12, 0x25, 0x0a, 0x20, 0x43, 0x4f, 0x55, + 0x4c, 0x44, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x53, 0x45, 0x52, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x45, + 0x5f, 0x53, 0x45, 0x52, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x8b, 0x01, + 0x12, 0x1e, 0x0a, 0x19, 0x49, 0x4e, 0x43, 0x4f, 0x4e, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x54, + 0x5f, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x5f, 0x42, 0x4f, 0x55, 0x4e, 0x44, 0x53, 0x10, 0x8c, 0x01, + 0x12, 0x17, 0x0a, 0x12, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x4f, 0x55, 0x54, 0x5f, 0x4f, 0x46, + 0x5f, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x10, 0x8d, 0x01, 0x12, 0x1a, 0x0a, 0x15, 0x4f, 0x42, 0x4a, + 0x45, 0x43, 0x54, 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x45, 0x58, 0x49, + 0x53, 0x54, 0x10, 0x8e, 0x01, 0x12, 0x21, 0x0a, 0x1c, 0x52, 0x4f, 0x57, 0x5f, 0x4c, 0x45, 0x56, + 0x45, 0x4c, 0x5f, 0x53, 0x45, 0x43, 0x55, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x56, 0x49, 0x4f, 0x4c, + 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x8f, 0x01, 0x12, 0x20, 0x0a, 0x1b, 0x57, 0x49, 0x54, 0x48, + 0x5f, 0x43, 0x48, 0x45, 0x43, 0x4b, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x49, + 0x4f, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x90, 0x01, 0x12, 0x17, 0x0a, 0x12, 0x43, 0x41, + 0x4e, 0x4e, 0x4f, 0x54, 0x5f, 0x4d, 0x4f, 0x44, 0x49, 0x46, 0x59, 0x5f, 0x56, 0x49, 0x45, 0x57, + 0x10, 0x91, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x53, 0x51, 0x4c, 0x5f, 0x4a, 0x53, 0x4f, 0x4e, 0x5f, + 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x92, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x50, 0x41, 0x52, 0x54, + 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x93, 0x01, 0x12, 0x1a, + 0x0a, 0x15, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x41, 0x4c, 0x52, 0x45, 0x41, 0x44, 0x59, + 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x10, 0x94, 0x01, 0x12, 0x16, 0x0a, 0x11, 0x57, 0x52, + 0x4f, 0x4e, 0x47, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, + 0x95, 0x01, 0x12, 0x1b, 0x0a, 0x16, 0x50, 0x47, 0x41, 0x5f, 0x43, 0x4f, 0x4c, 0x4c, 0x45, 0x43, + 0x54, 0x4f, 0x52, 0x5f, 0x49, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x46, 0x59, 0x10, 0xe8, 0x07, 0x22, + 0xc3, 0x06, 0x0a, 0x0b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x12, + 0x1b, 0x0a, 0x09, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x78, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x08, 0x71, 0x75, 0x65, 0x72, 0x79, 0x49, 0x64, 0x78, 0x12, 0x3b, 0x0a, 0x0b, + 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, + 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x41, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x75, 0x6e, + 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6d, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x72, + 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x54, 0x65, 0x78, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x65, 0x74, 0x65, 0x72, 0x73, 0x5f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x18, 0x05, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x10, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x4c, 0x65, + 0x67, 0x61, 0x63, 0x79, 0x12, 0x3f, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, + 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x70, 0x67, 0x61, 0x6e, 0x61, + 0x6c, 0x79, 0x7a, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x4e, + 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x22, 0x0a, 0x0d, 0x6c, 0x6f, 0x67, 0x5f, 0x6c, 0x69, 0x6e, + 0x65, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6c, 0x6f, + 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x55, 0x75, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x68, 0x61, 0x73, + 0x5f, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, + 0x68, 0x61, 0x73, 0x45, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x65, 0x78, + 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x15, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x5f, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, + 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x55, 0x0a, 0x0e, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, + 0x6e, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2e, + 0x2e, 0x70, 0x67, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x2e, 0x45, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x0d, + 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x55, 0x0a, + 0x0e, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, + 0x18, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2e, 0x2e, 0x70, 0x67, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, + 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x45, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x53, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x0d, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x53, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, + 0x65, 0x64, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, + 0x69, 0x7a, 0x65, 0x64, 0x22, 0x41, 0x0a, 0x0d, 0x45, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x46, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x17, 0x0a, 0x13, 0x54, 0x45, 0x58, 0x54, 0x5f, 0x45, 0x58, + 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x10, 0x00, 0x12, 0x17, + 0x0a, 0x13, 0x4a, 0x53, 0x4f, 0x4e, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x5f, 0x46, + 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x10, 0x01, 0x22, 0x8b, 0x01, 0x0a, 0x0d, 0x45, 0x78, 0x70, 0x6c, + 0x61, 0x69, 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x20, 0x0a, 0x1c, 0x53, 0x54, 0x41, + 0x54, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x4c, 0x4f, 0x47, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, + 0x49, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, 0x00, 0x12, 0x1f, 0x0a, 0x1b, 0x41, + 0x55, 0x54, 0x4f, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x5f, 0x45, 0x58, 0x50, 0x4c, + 0x41, 0x49, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, 0x01, 0x12, 0x1b, 0x0a, 0x17, + 0x45, 0x58, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, + 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, 0x02, 0x12, 0x1a, 0x0a, 0x16, 0x47, 0x45, 0x4e, + 0x45, 0x52, 0x49, 0x43, 0x5f, 0x45, 0x58, 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x5f, 0x53, 0x4f, 0x55, + 0x52, 0x43, 0x45, 0x10, 0x03, 0x42, 0x3b, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x67, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x2f, 0x63, 0x6f, + 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2f, 0x70, + 0x67, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( diff --git a/protobuf/compact_log_snapshot.proto b/protobuf/compact_log_snapshot.proto index 946d7058e..16193911c 100644 --- a/protobuf/compact_log_snapshot.proto +++ b/protobuf/compact_log_snapshot.proto @@ -129,7 +129,7 @@ message LogLineInformation { WAL_ARCHIVE_COMMAND_FAILED = 52; // "archive command failed" WAL_BASE_BACKUP_COMPLETE = 53; // "pg_stop_backup complete, all required WAL segments have been archived" - // Autovacuum + // Maintenance AUTOVACUUM_CANCEL = 60; // "canceling autovacuum task" TXID_WRAPAROUND_WARNING = 61; // "database * must be vacuumed within" TXID_WRAPAROUND_ERROR = 62; // "database is not accepting commands to avoid wraparound data loss" @@ -139,6 +139,7 @@ message LogLineInformation { AUTOANALYZE_COMPLETED = 66; // "automatic analyze of table" SKIPPING_VACUUM_LOCK_NOT_AVAILABLE = 67; // "skipping vacuum of ... --- lock not available" SKIPPING_ANALYZE_LOCK_NOT_AVAILABLE = 68; // "skipping analyze of ... --- lock not available" + SKIPPING_MAINTENANCE_PERMISSION_DENIED = 69; // "permission denied to {vacuum,analyze,execute CLUSTER on,execute REPACK on} ..., skipping it" // Locks LOCK_ACQUIRED = 70; // "acquired *Lock" @@ -202,6 +203,15 @@ message LogLineInformation { COULD_NOT_SERIALIZE_REPEATABLE_READ = 138; // "could not serialize access due to concurrent update" COULD_NOT_SERIALIZE_SERIALIZABLE = 139; // "could not serialize access due to read/write dependencies among transactions" INCONSISTENT_RANGE_BOUNDS = 140; // "range lower bound must be less than or equal to range upper bound" + VALUE_OUT_OF_RANGE = 141; // "... out of range", "... field value out of range", "numeric field overflow" (for non-integer types; integers use INTEGER_OUT_OF_RANGE) + OBJECT_DOES_NOT_EXIST = 142; // " ... does not exist" for object types without a dedicated classification (role, type, schema, index, collation, extension, ...); relations/columns/functions/operators use their own + ROW_LEVEL_SECURITY_VIOLATION = 143; // "new row violates row-level security policy for table ...", "query would be affected by row-level security policy for table ..." (errcode 42501) + WITH_CHECK_OPTION_VIOLATION = 144; // "new row violates check option for view ..." (errcode 44000) + CANNOT_MODIFY_VIEW = 145; // "cannot insert into/update/delete from/merge into [column ... of] view ..." for non-updatable views (errcodes 55000, 0A000) + SQL_JSON_ERROR = 146; // JSON / jsonpath / SQL-JSON processing errors (errcodes vary: 2203x SQL/JSON subclass, plus 22P02, 22023, 42601, 0A000, ...) + PARTITION_ERROR = 147; // partitioning DDL/operation errors: invalid bounds/keys, overlaps, cannot attach/detach/merge/split, ... (errcodes vary: 42P16, 42P17, 0A000; runtime routing/constraint failures use CHECK_CONSTRAINT_VIOLATION, "X is [not] a partition[ed] ..." uses WRONG_OBJECT_TYPE) + OBJECT_ALREADY_EXISTS = 148; // " ... already exists" for any object type (relation, type, column, constraint, function, ...) (duplicate_* errcodes: 42710, 42P07, 42701, 42723) + WRONG_OBJECT_TYPE = 149; // operation attempted on the wrong kind of object: "\"...\" is [not] a[n] " (incl. partition[ed] forms), "ALTER action ... cannot be performed on relation ..." (mostly errcode 42809; partition variants also 42P17/0A000) // Collector internal events PGA_COLLECTOR_IDENTIFY = 1000; // "pganalyze-collector-identify: server1"