Line data    Source code

       1              : use std::fmt;
       2              : 
       3              : use anyhow::Context;
       4              : use measured::FixedCardinalityLabel;
       5              : use tokio::task::JoinError;
       6              : 
       7              : /// Marks errors that may be safely shown to a client.
       8              : /// This trait can be seen as a specialized version of [`ToString`].
       9              : ///
      10              : /// NOTE: This trait should not be implemented for [`anyhow::Error`], since it
      11              : /// is way too convenient and tends to proliferate all across the codebase,
      12              : /// ultimately leading to accidental leaks of sensitive data.
      13              : pub(crate) trait UserFacingError: ReportableError {
      14              :     /// Format the error for client, stripping all sensitive info.
      15              :     ///
      16              :     /// Although this might be a no-op for many types, it's highly
      17              :     /// recommended to override the default impl in case error type
      18              :     /// contains anything sensitive: various IDs, IP addresses etc.
      19              :     #[inline(always)]
      20            0 :     fn to_string_client(&self) -> String {
      21            0 :         self.to_string()
      22            0 :     }
      23              : }
      24              : 
      25              : #[derive(Copy, Clone, Debug, Eq, PartialEq, FixedCardinalityLabel)]
      26              : #[label(singleton = "type")]
      27              : pub enum ErrorKind {
      28              :     /// Wrong password, unknown endpoint, protocol violation, etc...
      29              :     User,
      30              : 
      31              :     /// Network error between user and proxy. Not necessarily user error
      32              :     #[label(rename = "clientdisconnect")]
      33              :     ClientDisconnect,
      34              : 
      35              :     /// Proxy self-imposed user rate limits
      36              :     #[label(rename = "ratelimit")]
      37              :     RateLimit,
      38              : 
      39              :     /// Proxy self-imposed service-wise rate limits
      40              :     #[label(rename = "serviceratelimit")]
      41              :     ServiceRateLimit,
      42              : 
      43              :     /// Proxy quota limit violation
      44              :     #[label(rename = "quota")]
      45              :     Quota,
      46              : 
      47              :     /// internal errors
      48              :     Service,
      49              : 
      50              :     /// Error communicating with control plane
      51              :     #[label(rename = "controlplane")]
      52              :     ControlPlane,
      53              : 
      54              :     /// Postgres error
      55              :     Postgres,
      56              : 
      57              :     /// Error communicating with compute
      58              :     Compute,
      59              : }
      60              : 
      61              : impl ErrorKind {
      62            0 :     pub(crate) fn to_metric_label(self) -> &'static str {
      63            0 :         match self {
      64            0 :             ErrorKind::User => "user",
      65            0 :             ErrorKind::ClientDisconnect => "clientdisconnect",
      66            0 :             ErrorKind::RateLimit => "ratelimit",
      67            0 :             ErrorKind::ServiceRateLimit => "serviceratelimit",
      68            0 :             ErrorKind::Quota => "quota",
      69            0 :             ErrorKind::Service => "service",
      70            0 :             ErrorKind::ControlPlane => "controlplane",
      71            0 :             ErrorKind::Postgres => "postgres",
      72            0 :             ErrorKind::Compute => "compute",
      73              :         }
      74            0 :     }
      75              : }
      76              : 
      77              : pub(crate) trait ReportableError: fmt::Display + Send + 'static {
      78              :     fn get_error_kind(&self) -> ErrorKind;
      79              : }
      80              : 
      81              : impl ReportableError for postgres_client::error::Error {
      82            0 :     fn get_error_kind(&self) -> ErrorKind {
      83            0 :         if self.as_db_error().is_some() {
      84            0 :             ErrorKind::Postgres
      85              :         } else {
      86            0 :             ErrorKind::Compute
      87              :         }
      88            0 :     }
      89              : }
      90              : 
      91              : /// Flattens `Result<Result<T>>` into `Result<T>`.
      92            0 : pub fn flatten_err<T>(r: Result<anyhow::Result<T>, JoinError>) -> anyhow::Result<T> {
      93            0 :     r.context("join error").and_then(|x| x)
      94            0 : }