sfe: Create Salesforce Case at override request form submission time (#8438)

Author: beautifulentropy

cmd/email-exporter/main.go

@@ -45,7 +45,7 @@ type Config struct {
 		ClientSecret cmd.PasswordConfig
 
 		// SalesforceBaseURL is the base URL for the Salesforce API. (e.g.,
-		// "https://login.salesforce.com")
+		// "https://company.salesforce.com")
 		SalesforceBaseURL string `validate:"required"`
 
 		// PardotBaseURL is the base URL for the Pardot API. (e.g.,
@@ -100,7 +100,7 @@ func main() {
 		cache = email.NewHashedEmailCache(c.EmailExporter.EmailCacheSize, scope)
 	}
 
-	pardotClient, err := email.NewPardotClientImpl(
+	sfClient, err := email.NewSalesforceClientImpl(
 		clk,
 		c.EmailExporter.PardotBusinessUnit,
 		clientId,
@@ -109,7 +109,7 @@ func main() {
 		c.EmailExporter.PardotBaseURL,
 	)
 	cmd.FailOnError(err, "Creating Pardot API client")
-	exporterServer := email.NewExporterImpl(pardotClient, cache, c.EmailExporter.PerDayLimit, c.EmailExporter.MaxConcurrentRequests, scope, logger)
+	exporterServer := email.NewExporterImpl(sfClient, cache, c.EmailExporter.PerDayLimit, c.EmailExporter.MaxConcurrentRequests, scope, logger)
 
 	tlsConfig, err := c.EmailExporter.TLS.Load(scope)
 	cmd.FailOnError(err, "Loading email-exporter TLS config")

email/exporter.go

@@ -39,10 +39,11 @@ type ExporterImpl struct {
 
 	maxConcurrentRequests int
 	limiter               *rate.Limiter
-	client                PardotClient
+	client                SalesforceClient
 	emailCache            *EmailCache
 	emailsHandledCounter  prometheus.Counter
 	pardotErrorCounter    prometheus.Counter
+	caseErrorCounter      prometheus.Counter
 	log                   blog.Logger
 }
 
@@ -55,7 +56,7 @@ var _ emailpb.ExporterServer = (*ExporterImpl)(nil)
 // is assigned 40% (20,000 requests), it should also receive 40% of the max
 // concurrent requests (e.g., 2 out of 5). For more details, see:
 // https://developer.salesforce.com/docs/marketing/pardot/guide/overview.html?q=rate%20limits
-func NewExporterImpl(client PardotClient, cache *EmailCache, perDayLimit float64, maxConcurrentRequests int, scope prometheus.Registerer, logger blog.Logger) *ExporterImpl {
+func NewExporterImpl(client SalesforceClient, cache *EmailCache, perDayLimit float64, maxConcurrentRequests int, scope prometheus.Registerer, logger blog.Logger) *ExporterImpl {
 	limiter := rate.NewLimiter(rate.Limit(perDayLimit/86400.0), maxConcurrentRequests)
 
 	emailsHandledCounter := prometheus.NewCounter(prometheus.CounterOpts{
@@ -70,6 +71,12 @@ func NewExporterImpl(client PardotClient, cache *EmailCache, perDayLimit float64
 	})
 	scope.MustRegister(pardotErrorCounter)
 
+	caseErrorCounter := prometheus.NewCounter(prometheus.CounterOpts{
+		Name: "email_exporter_case_errors",
+		Help: "Total number of errors encountered when sending Cases to the Salesforce REST API",
+	})
+	scope.MustRegister(caseErrorCounter)
+
 	impl := &ExporterImpl{
 		maxConcurrentRequests: maxConcurrentRequests,
 		limiter:               limiter,
@@ -78,6 +85,7 @@ func NewExporterImpl(client PardotClient, cache *EmailCache, perDayLimit float64
 		emailCache:            cache,
 		emailsHandledCounter:  emailsHandledCounter,
 		pardotErrorCounter:    pardotErrorCounter,
+		caseErrorCounter:      caseErrorCounter,
 		log:                   logger,
 	}
 	impl.wake = sync.NewCond(&impl.Mutex)
@@ -116,6 +124,33 @@ func (impl *ExporterImpl) SendContacts(ctx context.Context, req *emailpb.SendCon
 	return &emptypb.Empty{}, nil
 }
 
+// SendCase immediately submits a new Case to the Salesforce REST API using the
+// provided details. Any retries are handled internally by the SalesforceClient.
+// The following fields are required: Origin, Subject, ContactEmail.
+func (impl *ExporterImpl) SendCase(ctx context.Context, req *emailpb.SendCaseRequest) (*emptypb.Empty, error) {
+	if core.IsAnyNilOrZero(req, req.Origin, req.Subject, req.ContactEmail) {
+		return nil, berrors.InternalServerError("incomplete gRPC request message")
+	}
+
+	err := impl.client.SendCase(Case{
+		Origin:        req.Origin,
+		Subject:       req.Subject,
+		Description:   req.Description,
+		ContactEmail:  req.ContactEmail,
+		Organization:  req.Organization,
+		AccountId:     req.AccountId,
+		RateLimitName: req.RateLimitName,
+		RateLimitTier: req.RateLimitTier,
+		UseCase:       req.UseCase,
+	})
+	if err != nil {
+		impl.caseErrorCounter.Inc()
+		return nil, berrors.InternalServerError("sending Case to the Salesforce REST API: %s", err)
+	}
+
+	return &emptypb.Empty{}, nil
+}
+
 // Start begins asynchronous processing of the email queue. When the parent
 // daemonCtx is cancelled the queue will be drained and the workers will exit.
 func (impl *ExporterImpl) Start(daemonCtx context.Context) {

email/exporter_test.go

@@ -18,46 +18,64 @@ import (
 
 var ctx = context.Background()
 
-// mockPardotClientImpl is a mock implementation of PardotClient.
-type mockPardotClientImpl struct {
+var _ SalesforceClient = (*mockSalesforceClientImpl)(nil)
+
+// mockSalesforceClientImpl is a mock implementation of PardotClient.
+type mockSalesforceClientImpl struct {
+	SalesforceClient
+
 	sync.Mutex
 	CreatedContacts []string
+	CreatedCases    []Case
 }
 
-// newMockPardotClientImpl returns a MockPardotClientImpl, implementing the
-// PardotClient interface. Both refer to the same instance, with the interface
-// for mock interaction and the struct for state inspection and modification.
-func newMockPardotClientImpl() *mockPardotClientImpl {
-	return &mockPardotClientImpl{
-		CreatedContacts: []string{},
-	}
+// newMockSalesforceClientImpl returns a mockSalesforceClientImpl, which implements
+// the PardotClient interface. It returns the underlying concrete type, so callers
+// have access to its struct members and helper methods.
+func newMockSalesforceClientImpl() *mockSalesforceClientImpl {
+	return &mockSalesforceClientImpl{}
 }
 
 // SendContact adds an email to CreatedContacts.
-func (m *mockPardotClientImpl) SendContact(email string) error {
+func (m *mockSalesforceClientImpl) SendContact(email string) error {
 	m.Lock()
+	defer m.Unlock()
 	m.CreatedContacts = append(m.CreatedContacts, email)
-	m.Unlock()
 	return nil
 }
 
-func (m *mockPardotClientImpl) getCreatedContacts() []string {
+func (m *mockSalesforceClientImpl) getCreatedContacts() []string {
 	m.Lock()
 	defer m.Unlock()
 
 	// Return a copy to avoid race conditions.
 	return slices.Clone(m.CreatedContacts)
 }
 
-// setup creates a new ExporterImpl, a MockPardotClientImpl, and the start and
+func (m *mockSalesforceClientImpl) SendCase(payload Case) error {
+	m.Lock()
+	defer m.Unlock()
+	m.CreatedCases = append(m.CreatedCases, payload)
+	return nil
+}
+
+func (m *mockSalesforceClientImpl) getCreatedCases() []Case {
+	m.Lock()
+	defer m.Unlock()
+
+	// Return a copy to avoid race conditions.
+	return slices.Clone(m.CreatedCases)
+}
+
+// setup creates a new ExporterImpl, a mockSalesForceClientImpl, and the start and
 // cleanup functions for the ExporterImpl. Call start() to begin processing the
 // ExporterImpl queue and cleanup() to drain and shutdown. If start() is called,
 // cleanup() must be called.
-func setup() (*ExporterImpl, *mockPardotClientImpl, func(), func()) {
-	mockClient := newMockPardotClientImpl()
-	exporter := NewExporterImpl(mockClient, nil, 1000000, 5, metrics.NoopRegisterer, blog.NewMock())
+func setup() (*ExporterImpl, *mockSalesforceClientImpl, func(), func()) {
+	clientImpl := newMockSalesforceClientImpl()
+	exporter := NewExporterImpl(clientImpl, nil, 1000000, 5, metrics.NoopRegisterer, blog.NewMock())
 	daemonCtx, cancel := context.WithCancel(context.Background())
-	return exporter, mockClient,
+	return exporter, clientImpl,
 		func() { exporter.Start(daemonCtx) },
 		func() {
 			cancel()
@@ -134,7 +152,9 @@ func TestSendContactsQueueDrains(t *testing.T) {
 	test.AssertEquals(t, 100, len(clientImpl.getCreatedContacts()))
 }
 
-type mockAlwaysFailClient struct{}
+type mockAlwaysFailClient struct {
+	mockSalesforceClientImpl
+}
 
 func (m *mockAlwaysFailClient) SendContact(email string) error {
 	return fmt.Errorf("simulated failure")
@@ -166,8 +186,8 @@ func TestSendContactDeduplication(t *testing.T) {
 	t.Parallel()
 
 	cache := NewHashedEmailCache(1000, metrics.NoopRegisterer)
-	mockClient := newMockPardotClientImpl()
-	exporter := NewExporterImpl(mockClient, cache, 1000000, 5, metrics.NoopRegisterer, blog.NewMock())
+	clientImpl := newMockSalesforceClientImpl()
+	exporter := NewExporterImpl(clientImpl, cache, 1000000, 5, metrics.NoopRegisterer, blog.NewMock())
 
 	daemonCtx, cancel := context.WithCancel(context.Background())
 	exporter.Start(daemonCtx)
@@ -181,7 +201,7 @@ func TestSendContactDeduplication(t *testing.T) {
 	cancel()
 	exporter.Drain()
 
-	contacts := mockClient.getCreatedContacts()
+	contacts := clientImpl.getCreatedContacts()
 	test.AssertEquals(t, 1, len(contacts))
 	test.AssertEquals(t, "[email protected]", contacts[0])
 
@@ -222,3 +242,68 @@ func TestSendContactErrorRemovesFromCache(t *testing.T) {
 	// Check that the error counter was incremented.
 	test.AssertMetricWithLabelsEquals(t, exporter.pardotErrorCounter, prometheus.Labels{}, 1)
 }
+
+func TestSendCase(t *testing.T) {
+	t.Parallel()
+
+	clientImpl := newMockSalesforceClientImpl()
+	exporter := NewExporterImpl(clientImpl, nil, 1000000, 5, metrics.NoopRegisterer, blog.NewMock())
+
+	_, err := exporter.SendCase(ctx, &emailpb.SendCaseRequest{
+		Origin:       "Web",
+		Subject:      "Some Override",
+		Description:  "Please review",
+		ContactEmail: "[email protected]",
+	})
+	test.AssertNotError(t, err, "SendCase should succeed")
+
+	got := clientImpl.getCreatedCases()
+	if len(got) != 1 {
+		t.Fatalf("expected 1 case, got %d", len(got))
+	}
+	test.AssertEquals(t, got[0].Origin, "Web")
+	test.AssertEquals(t, got[0].Subject, "Some Override")
+	test.AssertEquals(t, got[0].Description, "Please review")
+	test.AssertEquals(t, got[0].ContactEmail, "[email protected]")
+	test.AssertMetricWithLabelsEquals(t, exporter.caseErrorCounter, prometheus.Labels{}, 0)
+}
+
+type mockAlwaysFailCaseClient struct {
+	mockSalesforceClientImpl
+}
+
+func (m *mockAlwaysFailCaseClient) SendCase(payload Case) error {
+	return fmt.Errorf("oops, lol")
+}
+
+func TestSendCaseClientErrorIncrementsMetric(t *testing.T) {
+	t.Parallel()
+
+	mockClient := &mockAlwaysFailCaseClient{}
+	exporter := NewExporterImpl(mockClient, nil, 1000000, 5, metrics.NoopRegisterer, blog.NewMock())
+
+	_, err := exporter.SendCase(ctx, &emailpb.SendCaseRequest{
+		Origin:       "Web",
+		Subject:      "Some Override",
+		Description:  "Please review",
+		ContactEmail: "[email protected]",
+	})
+	test.AssertError(t, err, "SendCase should return error on client failure")
+	test.AssertMetricWithLabelsEquals(t, exporter.caseErrorCounter, prometheus.Labels{}, 1)
+}
+
+func TestSendCaseMissingOriginValidation(t *testing.T) {
+	t.Parallel()
+
+	clientImpl := newMockSalesforceClientImpl()
+	exporter := NewExporterImpl(clientImpl, nil, 1000000, 5, metrics.NoopRegisterer, blog.NewMock())
+
+	_, err := exporter.SendCase(ctx, &emailpb.SendCaseRequest{Subject: "No origin in this one, d00d"})
+	test.AssertError(t, err, "SendCase should fail validation when Origin is missing")
+
+	got := clientImpl.getCreatedCases()
+	if len(got) != 0 {
+		t.Errorf("expected 0 cases due to validation error, got %d", len(got))
+	}
+	test.AssertMetricWithLabelsEquals(t, exporter.caseErrorCounter, prometheus.Labels{}, 0)
+}