Add logging flags for tuple writes

cmd/tuple/delete.go

@@ -49,6 +49,23 @@ var deleteCmd = &cobra.Command{
 		}
 		if fileName != "" {
 			startTime := time.Now()
+			successPath, _ := cmd.Flags().GetString("success-log")
+			failurePath, _ := cmd.Flags().GetString("failure-log")
+			var successLogger, failureLogger *tuple.TupleLogger
+			if successPath != "" {
+				successLogger, err = tuple.NewTupleLogger(successPath, false)
+				if err != nil {
+					return err
+				}
+				defer successLogger.Close()
+			}
+			if failurePath != "" {
+				failureLogger, err = tuple.NewTupleLogger(failurePath, true)
+				if err != nil {
+					return err
+				}
+				defer failureLogger.Close()
+			}
 
 			clientTupleKeys, err := tuplefile.ReadTupleFile(fileName)
 			if err != nil {
@@ -70,8 +87,10 @@ var deleteCmd = &cobra.Command{
 				Deletes: clientTupleKeyWithoutCondition,
 			}
 
+			newCtx := tuple.WithSuccessLogger(cmd.Context(), successLogger)
+			newCtx = tuple.WithFailureLogger(newCtx, failureLogger)
 			response, err := tuple.ImportTuplesWithoutRampUp(
-				cmd.Context(), fgaClient,
+				newCtx, fgaClient,
 				maxTuplesPerWrite, maxParallelRequests,
 				writeRequest)
 			if err != nil {
@@ -83,11 +102,11 @@ var deleteCmd = &cobra.Command{
 
 			outputResponse := make(map[string]interface{})
 
-			if !hideImportedTuples && len(response.Successful) > 0 {
+			if !hideImportedTuples && successPath == "" && len(response.Successful) > 0 {
 				outputResponse["successful"] = response.Successful
 			}
 
-			if len(response.Failed) > 0 {
+			if failurePath == "" && len(response.Failed) > 0 {
 				outputResponse["failed"] = response.Failed
 			}
 

cmd/tuple/tuple.go

@@ -38,6 +38,8 @@ func init() {
 	TupleCmd.AddCommand(deleteCmd)
 
 	TupleCmd.PersistentFlags().String("store-id", "", "Store ID")
+	TupleCmd.PersistentFlags().String("success-log", "", "Filepath to log successful writes")
+	TupleCmd.PersistentFlags().String("failure-log", "", "Filepath to log failed writes")
 
 	err := TupleCmd.MarkPersistentFlagRequired("store-id")
 	if err != nil { //nolint:wsl

cmd/tuple/write.go

@@ -233,6 +233,26 @@ func writeTuplesFromFile(ctx context.Context, flags *flag.FlagSet, fgaClient *cl
 		return fmt.Errorf("failed to parse debug flag due to %w", err)
 	}
 
+	successPath, _ := flags.GetString("success-log")
+	failurePath, _ := flags.GetString("failure-log")
+
+	var successLogger, failureLogger *tuple.TupleLogger
+	if successPath != "" {
+		successLogger, err = tuple.NewTupleLogger(successPath, false)
+		if err != nil {
+			return err
+		}
+		defer successLogger.Close()
+	}
+
+	if failurePath != "" {
+		failureLogger, err = tuple.NewTupleLogger(failurePath, true)
+		if err != nil {
+			return err
+		}
+		defer failureLogger.Close()
+	}
+
 	tuples, err := tuplefile.ReadTupleFile(fileName)
 	if err != nil {
 		return err //nolint:wrapcheck
@@ -243,6 +263,8 @@ func writeTuplesFromFile(ctx context.Context, flags *flag.FlagSet, fgaClient *cl
 	}
 
 	newCtx := utils.WithDebugContext(ctx, debug)
+	newCtx = tuple.WithSuccessLogger(newCtx, successLogger)
+	newCtx = tuple.WithFailureLogger(newCtx, failureLogger)
 
 	response, err := tuple.ImportTuples(
 		newCtx, fgaClient,
@@ -257,11 +279,11 @@ func writeTuplesFromFile(ctx context.Context, flags *flag.FlagSet, fgaClient *cl
 
 	outputResponse := make(map[string]interface{})
 
-	if !hideImportedTuples && len(response.Successful) > 0 {
+	if !hideImportedTuples && successPath == "" && len(response.Successful) > 0 {
 		outputResponse["successful"] = response.Successful
 	}
 
-	if len(response.Failed) > 0 {
+	if failurePath == "" && len(response.Failed) > 0 {
 		outputResponse["failed"] = response.Failed
 	}
 

internal/tuple/import.go

@@ -140,7 +140,7 @@ func importTuplesWithoutRampUp(
 		return nil, fmt.Errorf("failed to import tuples due to %w", err)
 	}
 
-	successful, failed := processWritesAndDeletes(response)
+	successful, failed := processWritesAndDeletes(ctx, response)
 	result := ImportResponse{
 		Successful: successful,
 		Failed:     failed,
@@ -215,8 +215,8 @@ func importTuplesWithRampUp(ctx context.Context, fgaClient client.SdkClient,
 				return err //nolint:wrapcheck
 			}
 
-			successfulWrites, failedWrites := processWrites(response.Writes)
-			successfulDeletes, failedDeletes := processDeletes(response.Deletes)
+			successfulWrites, failedWrites := processWrites(ctx, response.Writes)
+			successfulDeletes, failedDeletes := processDeletes(ctx, response.Deletes)
 
 			mutex.Lock()
 
@@ -298,45 +298,61 @@ func extractErrMsg(err error) string {
 }
 
 func processWritesAndDeletes(
+	ctx context.Context,
 	response *client.ClientWriteResponse,
 ) ([]client.ClientTupleKey, []failedWriteResponse) {
-	successfulWrites, failedWrites := processWrites(response.Writes)
-	successfulDeletes, failedDeletes := processDeletes(response.Deletes)
+	successfulWrites, failedWrites := processWrites(ctx, response.Writes)
+	successfulDeletes, failedDeletes := processDeletes(ctx, response.Deletes)
 
 	return append(successfulWrites, successfulDeletes...), append(failedWrites, failedDeletes...)
 }
 
 func processWrites(
+	ctx context.Context,
 	writes []client.ClientWriteRequestWriteResponse,
 ) ([]client.ClientTupleKey, []failedWriteResponse) {
 	var (
 		successfulWrites []client.ClientTupleKey
 		failedWrites     []failedWriteResponse
 	)
 
+	successLogger := getSuccessLogger(ctx)
+	failureLogger := getFailureLogger(ctx)
+
 	for _, write := range writes {
 		if write.Status == client.SUCCESS {
 			successfulWrites = append(successfulWrites, write.TupleKey)
+			if successLogger != nil {
+				successLogger.LogSuccess(write.TupleKey)
+			}
 		} else {
 			reason := extractErrMsg(write.Error)
-			failedWrites = append(failedWrites, failedWriteResponse{
+			failed := failedWriteResponse{
 				TupleKey: write.TupleKey,
 				Reason:   reason,
-			})
+			}
+			failedWrites = append(failedWrites, failed)
+			if failureLogger != nil {
+				failureLogger.LogFailure(failed)
+			}
 		}
 	}
 
 	return successfulWrites, failedWrites
 }
 
 func processDeletes(
+	ctx context.Context,
 	deletes []client.ClientWriteRequestDeleteResponse,
 ) ([]client.ClientTupleKey, []failedWriteResponse) {
 	var (
 		successfulDeletes []client.ClientTupleKey
 		failedDeletes     []failedWriteResponse
 	)
 
+	successLogger := getSuccessLogger(ctx)
+	failureLogger := getFailureLogger(ctx)
+
 	for _, del := range deletes {
 		deletedTupleKey := openfga.TupleKey{
 			Object:   del.TupleKey.Object,
@@ -346,12 +362,19 @@ func processDeletes(
 
 		if del.Status == client.SUCCESS {
 			successfulDeletes = append(successfulDeletes, deletedTupleKey)
+			if successLogger != nil {
+				successLogger.LogSuccess(deletedTupleKey)
+			}
 		} else {
 			reason := extractErrMsg(del.Error)
-			failedDeletes = append(failedDeletes, failedWriteResponse{
+			failed := failedWriteResponse{
 				TupleKey: deletedTupleKey,
 				Reason:   reason,
-			})
+			}
+			failedDeletes = append(failedDeletes, failed)
+			if failureLogger != nil {
+				failureLogger.LogFailure(failed)
+			}
 		}
 	}
 

internal/tuple/import_test.go

@@ -1,6 +1,7 @@
 package tuple
 
 import (
+	"context"
 	"errors"
 	"testing"
 
@@ -23,7 +24,7 @@ func TestProcessWrites(t *testing.T) {
 		},
 	}
 
-	successful, failed := processWrites(writes)
+	successful, failed := processWrites(context.Background(), writes)
 
 	assert.Len(t, successful, 1)
 	assert.Len(t, failed, 1)
@@ -45,7 +46,7 @@ func TestProcessDeletes(t *testing.T) {
 		},
 	}
 
-	successful, failed := processDeletes(deletes)
+	successful, failed := processDeletes(context.Background(), deletes)
 
 	assert.Len(t, successful, 1)
 	assert.Len(t, failed, 1)

internal/tuple/logger.go

@@ -0,0 +1,137 @@
+package tuple
+
+import (
+	"bufio"
+	"context"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/openfga/go-sdk/client"
+	"gopkg.in/yaml.v3"
+)
+
+// TupleLogger writes tuple logs in various formats.
+type TupleLogger struct {
+	file          *os.File
+	writer        *bufio.Writer
+	format        string
+	headerWritten bool
+	isFailure     bool
+}
+
+// NewTupleLogger creates a logger for the given file path.
+func NewTupleLogger(path string, isFailure bool) (*TupleLogger, error) {
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open log file %s: %w", path, err)
+	}
+
+	info, err := f.Stat()
+	if err != nil {
+		_ = f.Close()
+		return nil, fmt.Errorf("failed to stat log file %s: %w", path, err)
+	}
+
+	return &TupleLogger{
+		file:          f,
+		writer:        bufio.NewWriter(f),
+		format:        strings.ToLower(filepath.Ext(path)),
+		headerWritten: info.Size() > 0,
+		isFailure:     isFailure,
+	}, nil
+}
+
+func (l *TupleLogger) Close() error {
+	if l == nil {
+		return nil
+	}
+	_ = l.writer.Flush()
+	_ = l.file.Sync()
+	return l.file.Close()
+}
+
+func (l *TupleLogger) flush() {
+	_ = l.writer.Flush()
+	_ = l.file.Sync()
+}
+
+// LogSuccess writes a successful tuple key.
+func (l *TupleLogger) LogSuccess(key client.ClientTupleKey) {
+	if l == nil {
+		return
+	}
+	switch l.format {
+	case ".csv":
+		l.writeCSV([]string{key.User, key.Relation, key.Object})
+	case ".yaml", ".yml":
+		b, _ := yaml.Marshal(key)
+		l.writer.Write(b)
+		l.writer.Write([]byte("---\n"))
+	default: // json and jsonl
+		b, _ := json.Marshal(key)
+		l.writer.Write(append(b, '\n'))
+	}
+	l.flush()
+}
+
+// LogFailure writes a failed tuple with reason.
+func (l *TupleLogger) LogFailure(failed failedWriteResponse) {
+	if l == nil {
+		return
+	}
+	switch l.format {
+	case ".csv":
+		l.writeCSV([]string{failed.TupleKey.User, failed.TupleKey.Relation, failed.TupleKey.Object, failed.Reason})
+	case ".yaml", ".yml":
+		b, _ := yaml.Marshal(failed)
+		l.writer.Write(b)
+		l.writer.Write([]byte("---\n"))
+	default:
+		b, _ := json.Marshal(failed)
+		l.writer.Write(append(b, '\n'))
+	}
+	l.flush()
+}
+
+func (l *TupleLogger) writeCSV(record []string) {
+	w := csv.NewWriter(l.writer)
+	if !l.headerWritten {
+		if l.isFailure {
+			w.Write([]string{"user", "relation", "object", "reason"})
+		} else {
+			w.Write([]string{"user", "relation", "object"})
+		}
+		l.headerWritten = true
+	}
+	_ = w.Write(record)
+	w.Flush()
+}
+
+// Context utilities
+
+type logKey struct{ name string }
+
+var successLogKey = &logKey{"successLog"}
+var failureLogKey = &logKey{"failureLog"}
+
+func WithSuccessLogger(ctx context.Context, l *TupleLogger) context.Context {
+	return context.WithValue(ctx, successLogKey, l)
+}
+
+func WithFailureLogger(ctx context.Context, l *TupleLogger) context.Context {
+	return context.WithValue(ctx, failureLogKey, l)
+}
+
+func getSuccessLogger(ctx context.Context) *TupleLogger {
+	logger, _ := ctx.Value(successLogKey).(*TupleLogger)
+	return logger
+}
+
+func getFailureLogger(ctx context.Context) *TupleLogger {
+	logger, _ := ctx.Value(failureLogKey).(*TupleLogger)
+	return logger
+}