Add ChannelConnection.errorReason and start populating

core/ivr/ivr.go

@@ -78,7 +78,9 @@ type Client interface {
 
 	ResumeForRequest(r *http.Request) (Resume, error)
 
-	StatusForRequest(r *http.Request) (models.ConnectionStatus, int)
+	// StatusForRequest returns the call status for the passed in request, and if it's an error the reason,
+	// and if available, the current call duration
+	StatusForRequest(r *http.Request) (models.ConnectionStatus, models.ConnectionError, int)
 
 	PreprocessResume(ctx context.Context, db *sqlx.DB, rp *redis.Pool, conn *models.ChannelConnection, r *http.Request) ([]byte, error)
 
@@ -445,7 +447,7 @@ func ResumeIVRFlow(
 	}
 
 	// make sure our call is still happening
-	status, _ := client.StatusForRequest(r)
+	status, _, _ := client.StatusForRequest(r)
 	if status != models.ConnectionStatusInProgress {
 		err := conn.UpdateStatus(ctx, rt.DB, status, 0, time.Now())
 		if err != nil {
@@ -588,7 +590,7 @@ func buildMsgResume(
 // ended for some reason and update the state of the call and session if so
 func HandleIVRStatus(ctx context.Context, rt *runtime.Runtime, oa *models.OrgAssets, client Client, conn *models.ChannelConnection, r *http.Request, w http.ResponseWriter) error {
 	// read our status and duration from our client
-	status, duration := client.StatusForRequest(r)
+	status, errorReason, duration := client.StatusForRequest(r)
 
 	// if we errored schedule a retry if appropriate
 	if status == models.ConnectionStatusErrored {
@@ -609,7 +611,7 @@ func HandleIVRStatus(ctx context.Context, rt *runtime.Runtime, oa *models.OrgAss
 			return errors.Wrapf(err, "unable to load flow: %d", start.FlowID())
 		}
 
-		conn.MarkErrored(ctx, rt.DB, time.Now(), flow.IVRRetryWait())
+		conn.MarkErrored(ctx, rt.DB, time.Now(), flow.IVRRetryWait(), errorReason)
 
 		if conn.Status() == models.ConnectionStatusErrored {
 			return client.WriteEmptyResponse(w, fmt.Sprintf("status updated: %s next_attempt: %s", conn.Status(), conn.NextAttempt()))

core/ivr/twiml/twiml.go

@@ -287,37 +287,42 @@ func (c *client) ResumeForRequest(r *http.Request) (ivr.Resume, error) {
 	}
 }
 
-// StatusForRequest returns the current call status for the passed in status (and optional duration if known)
-func (c *client) StatusForRequest(r *http.Request) (models.ConnectionStatus, int) {
+// StatusForRequest returns the call status for the passed in request, and if it's an error the reason,
+// and if available, the current call duration
+func (c *client) StatusForRequest(r *http.Request) (models.ConnectionStatus, models.ConnectionError, int) {
 	// we re-use our status callback for AMD results which will have an AnsweredBy field but no CallStatus field
 	answeredBy := r.Form.Get("AnsweredBy")
 	if answeredBy != "" {
 		switch answeredBy {
 		case "machine_start", "fax":
-			return models.ConnectionStatusErrored, 0
+			return models.ConnectionStatusErrored, models.ConnectionErrorMachine, 0
 		}
-		return models.ConnectionStatusInProgress, 0
+		return models.ConnectionStatusInProgress, models.ConnectionNoError, 0
 	}
 
 	status := r.Form.Get("CallStatus")
 	switch status {
 
 	case "queued", "ringing":
-		return models.ConnectionStatusWired, 0
+		return models.ConnectionStatusWired, models.ConnectionNoError, 0
 
 	case "in-progress", "initiated":
-		return models.ConnectionStatusInProgress, 0
+		return models.ConnectionStatusInProgress, models.ConnectionNoError, 0
 
 	case "completed":
 		duration, _ := strconv.Atoi(r.Form.Get("CallDuration"))
-		return models.ConnectionStatusCompleted, duration
+		return models.ConnectionStatusCompleted, models.ConnectionNoError, duration
 
-	case "busy", "no-answer", "canceled", "failed":
-		return models.ConnectionStatusErrored, 0
+	case "busy":
+		return models.ConnectionStatusErrored, models.ConnectionErrorBusy, 0
+	case "no-answer":
+		return models.ConnectionStatusErrored, models.ConnectionErrorNoAnswer, 0
+	case "canceled", "failed":
+		return models.ConnectionStatusErrored, models.ConnectionNoError, 0
 
 	default:
 		logrus.WithField("call_status", status).Error("unknown call status in status callback")
-		return models.ConnectionStatusFailed, 0
+		return models.ConnectionStatusFailed, models.ConnectionErrorProvider, 0
 	}
 }
 

core/ivr/vonage/vonage.go

@@ -543,47 +543,53 @@ type StatusRequest struct {
 }
 
 // StatusForRequest returns the current call status for the passed in status (and optional duration if known)
-func (c *client) StatusForRequest(r *http.Request) (models.ConnectionStatus, int) {
+func (c *client) StatusForRequest(r *http.Request) (models.ConnectionStatus, models.ConnectionError, int) {
 	// this is a resume, call is in progress, no need to look at the body
 	if r.Form.Get("action") == "resume" {
-		return models.ConnectionStatusInProgress, 0
+		return models.ConnectionStatusInProgress, models.ConnectionNoError, 0
 	}
 
 	status := &StatusRequest{}
 	bb, err := readBody(r)
 	if err != nil {
 		logrus.WithError(err).Error("error reading status request body")
-		return models.ConnectionStatusErrored, 0
+		return models.ConnectionStatusErrored, models.ConnectionNoError, 0
 	}
 	err = json.Unmarshal(bb, status)
 	if err != nil {
 		logrus.WithError(err).WithField("body", string(bb)).Error("error unmarshalling ncco status")
-		return models.ConnectionStatusErrored, 0
+		return models.ConnectionStatusErrored, models.ConnectionNoError, 0
 	}
 
 	// transfer status callbacks have no status, safe to ignore them
 	if status.Status == "" {
-		return models.ConnectionStatusInProgress, 0
+		return models.ConnectionStatusInProgress, models.ConnectionNoError, 0
 	}
 
 	switch status.Status {
 
 	case "started", "ringing":
-		return models.ConnectionStatusWired, 0
+		return models.ConnectionStatusWired, models.ConnectionNoError, 0
 
 	case "answered":
-		return models.ConnectionStatusInProgress, 0
+		return models.ConnectionStatusInProgress, models.ConnectionNoError, 0
 
 	case "completed":
 		duration, _ := strconv.Atoi(status.Duration)
-		return models.ConnectionStatusCompleted, duration
+		return models.ConnectionStatusCompleted, models.ConnectionNoError, duration
 
-	case "rejected", "busy", "unanswered", "timeout", "failed", "machine":
-		return models.ConnectionStatusErrored, 0
+	case "busy":
+		return models.ConnectionStatusErrored, models.ConnectionErrorBusy, 0
+	case "rejected", "unanswered", "timeout":
+		return models.ConnectionStatusErrored, models.ConnectionErrorNoAnswer, 0
+	case "machine":
+		return models.ConnectionStatusErrored, models.ConnectionErrorMachine, 0
+	case "failed":
+		return models.ConnectionStatusErrored, models.ConnectionErrorProvider, 0
 
 	default:
 		logrus.WithField("status", status.Status).Error("unknown call status in ncco callback")
-		return models.ConnectionStatusFailed, 0
+		return models.ConnectionStatusFailed, models.ConnectionErrorProvider, 0
 	}
 }
 

core/models/channel_connection.go

@@ -20,6 +20,9 @@ const NilConnectionID = ConnectionID(0)
 // ConnectionStatus is the type for the status of a connection
 type ConnectionStatus string
 
+// ConnectionError is the type for the reason of an errored connection
+type ConnectionError null.String
+
 // ConnectionDirection is the type for the direction of a connection
 type ConnectionDirection string
 
@@ -39,16 +42,19 @@ const (
 
 // connection status constants
 const (
-	ConnectionStatusPending    = ConnectionStatus("P")
-	ConnectionStatusQueued     = ConnectionStatus("Q")
-	ConnectionStatusWired      = ConnectionStatus("W")
-	ConnectionStatusInProgress = ConnectionStatus("I")
-	ConnectionStatusBusy       = ConnectionStatus("B")
-	ConnectionStatusFailed     = ConnectionStatus("F")
-	ConnectionStatusErrored    = ConnectionStatus("E")
-	ConnectionStatusNoAnswer   = ConnectionStatus("N")
-	ConnectionStatusCancelled  = ConnectionStatus("C")
-	ConnectionStatusCompleted  = ConnectionStatus("D")
+	ConnectionStatusPending    = ConnectionStatus("P") // used for initial creation in database
+	ConnectionStatusQueued     = ConnectionStatus("Q") // call can't be wired yet and is queued locally
+	ConnectionStatusWired      = ConnectionStatus("W") // call has been requested on the IVR provider
+	ConnectionStatusInProgress = ConnectionStatus("I") // call was answered and is in progress
+	ConnectionStatusCompleted  = ConnectionStatus("D") // call was completed successfully
+	ConnectionStatusErrored    = ConnectionStatus("E") // temporary failure (will be retried)
+	ConnectionStatusFailed     = ConnectionStatus("F") // permanent failure
+
+	ConnectionErrorProvider = ConnectionError("P")
+	ConnectionErrorBusy     = ConnectionError("B")
+	ConnectionErrorNoAnswer = ConnectionError("N")
+	ConnectionErrorMachine  = ConnectionError("M")
+	ConnectionNoError       = ConnectionError("")
 
 	ConnectionMaxRetries = 3
 
@@ -72,8 +78,9 @@ type ChannelConnection struct {
 		EndedOn        *time.Time          `json:"ended_on"        db:"ended_on"`
 		ConnectionType ConnectionType      `json:"connection_type" db:"connection_type"`
 		Duration       int                 `json:"duration"        db:"duration"`
-		RetryCount     int                 `json:"retry_count"     db:"retry_count"`
-		ErrorCount     int                 `json:"error_count"     db:"retry_count"`
+		RetryCount     int                 `json:"retry_count"     db:"retry_count"` // TODO replace use with error_count
+		ErrorReason    null.String         `json:"error_reason"    db:"error_reason"`
+		ErrorCount     int                 `json:"error_count"     db:"error_count"`
 		NextAttempt    *time.Time          `json:"next_attempt"    db:"next_attempt"`
 		ChannelID      ChannelID           `json:"channel_id"      db:"channel_id"`
 		ContactID      ContactID           `json:"contact_id"      db:"contact_id"`
@@ -89,13 +96,16 @@ func (c *ChannelConnection) ID() ConnectionID { return c.c.ID }
 // Status returns the status of this connection
 func (c *ChannelConnection) Status() ConnectionStatus { return c.c.Status }
 
-func (c *ChannelConnection) NextAttempt() *time.Time { return c.c.NextAttempt }
-func (c *ChannelConnection) ExternalID() string      { return c.c.ExternalID }
-func (c *ChannelConnection) OrgID() OrgID            { return c.c.OrgID }
-func (c *ChannelConnection) ContactID() ContactID    { return c.c.ContactID }
-func (c *ChannelConnection) ContactURNID() URNID     { return c.c.ContactURNID }
-func (c *ChannelConnection) ChannelID() ChannelID    { return c.c.ChannelID }
-func (c *ChannelConnection) StartID() StartID        { return c.c.StartID }
+func (c *ChannelConnection) ExternalID() string   { return c.c.ExternalID }
+func (c *ChannelConnection) OrgID() OrgID         { return c.c.OrgID }
+func (c *ChannelConnection) ContactID() ContactID { return c.c.ContactID }
+func (c *ChannelConnection) ContactURNID() URNID  { return c.c.ContactURNID }
+func (c *ChannelConnection) ChannelID() ChannelID { return c.c.ChannelID }
+func (c *ChannelConnection) StartID() StartID     { return c.c.StartID }
+
+func (c *ChannelConnection) ErrorReason() ConnectionError { return ConnectionError(c.c.ErrorReason) }
+func (c *ChannelConnection) ErrorCount() int              { return c.c.ErrorCount }
+func (c *ChannelConnection) NextAttempt() *time.Time      { return c.c.NextAttempt }
 
 const insertConnectionSQL = `
 INSERT INTO
@@ -199,6 +209,7 @@ SELECT
 	cc.connection_type as connection_type, 
 	cc.duration as duration, 
 	cc.retry_count as retry_count, 
+	cc.error_reason as error_reason,
 	cc.error_count as error_count,
 	cc.next_attempt as next_attempt, 
 	cc.channel_id as channel_id, 
@@ -236,6 +247,7 @@ SELECT
 	cc.connection_type as connection_type, 
 	cc.duration as duration, 
 	cc.retry_count as retry_count, 
+	cc.error_reason as error_reason,
 	cc.error_count as error_count,
 	cc.next_attempt as next_attempt, 
 	cc.channel_id as channel_id, 
@@ -278,6 +290,7 @@ SELECT
 	cc.connection_type as connection_type, 
 	cc.duration as duration, 
 	cc.retry_count as retry_count, 
+	cc.error_reason as error_reason,
 	cc.error_count as error_count,
 	cc.next_attempt as next_attempt, 
 	cc.channel_id as channel_id, 
@@ -352,11 +365,18 @@ func (c *ChannelConnection) MarkStarted(ctx context.Context, db Queryer, now tim
 }
 
 // MarkErrored updates the status for this connection to errored and schedules a retry if appropriate
-func (c *ChannelConnection) MarkErrored(ctx context.Context, db Queryer, now time.Time, retryWait *time.Duration) error {
+func (c *ChannelConnection) MarkErrored(ctx context.Context, db Queryer, now time.Time, retryWait *time.Duration, errorReason ConnectionError) error {
 	c.c.Status = ConnectionStatusErrored
+	c.c.ErrorReason = null.String(errorReason)
 	c.c.EndedOn = &now
 
-	if c.c.RetryCount < ConnectionMaxRetries && retryWait != nil {
+	// TODO remove this once we only use error_count
+	errorCount := c.c.ErrorCount
+	if c.c.RetryCount > errorCount {
+		errorCount = c.c.RetryCount
+	}
+
+	if errorCount < ConnectionMaxRetries && retryWait != nil {
 		c.c.RetryCount++
 		c.c.ErrorCount++
 		next := now.Add(*retryWait)

core/tasks/ivr/worker_test.go

@@ -102,8 +102,8 @@ func (c *MockClient) ResumeForRequest(r *http.Request) (ivr.Resume, error) {
 	return nil, nil
 }
 
-func (c *MockClient) StatusForRequest(r *http.Request) (models.ConnectionStatus, int) {
-	return models.ConnectionStatusFailed, 10
+func (c *MockClient) StatusForRequest(r *http.Request) (models.ConnectionStatus, models.ConnectionError, int) {
+	return models.ConnectionStatusFailed, models.ConnectionErrorProvider, 10
 }
 
 func (c *MockClient) PreprocessResume(ctx context.Context, db *sqlx.DB, rp *redis.Pool, conn *models.ChannelConnection, r *http.Request) ([]byte, error) {