rmv test debuq

Signed-off-by: MJarmo <[email protected]>

Author: MJarmo

exporter/debugexporter/exporter.go

@@ -5,39 +5,25 @@ package debugexporter // import "go.opentelemetry.io/collector/exporter/debugexp
 
 import (
 	"context"
-	"fmt"
-	"os"
-	"sync"
-	"sync/atomic"
 
 	"go.uber.org/zap"
 
 	"go.opentelemetry.io/collector/config/configtelemetry"
 	"go.opentelemetry.io/collector/exporter/debugexporter/internal/normal"
 	"go.opentelemetry.io/collector/exporter/debugexporter/internal/otlptext"
-	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/plog"
 	"go.opentelemetry.io/collector/pdata/pmetric"
 	"go.opentelemetry.io/collector/pdata/pprofile"
 	"go.opentelemetry.io/collector/pdata/ptrace"
 )
 
-var failureCnt atomic.Int32
-
 type debugExporter struct {
 	verbosity         configtelemetry.Level
 	logger            *zap.Logger
 	logsMarshaler     plog.Marshaler
 	metricsMarshaler  pmetric.Marshaler
 	tracesMarshaler   ptrace.Marshaler
 	profilesMarshaler pprofile.Marshaler
-	receivedLogs      sync.Map
-
-	totalLogsCount  atomic.Int64
-	exportCallCount atomic.Int64
-	expectedLogs    int64
-	logFile         *os.File
-	fileMutex       sync.Mutex
 }
 
 func newDebugExporter(logger *zap.Logger, verbosity configtelemetry.Level) *debugExporter {
@@ -56,21 +42,13 @@ func newDebugExporter(logger *zap.Logger, verbosity configtelemetry.Level) *debu
 		tracesMarshaler = normal.NewNormalTracesMarshaler()
 		profilesMarshaler = normal.NewNormalProfilesMarshaler()
 	}
-
-	logFile, err := os.OpenFile("test-logs.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
-	if err != nil {
-		logger.Error("Failed to open test-logs.txt for writing", zap.Error(err))
-	}
-
 	return &debugExporter{
 		verbosity:         verbosity,
 		logger:            logger,
 		logsMarshaler:     logsMarshaler,
 		metricsMarshaler:  metricsMarshaler,
 		tracesMarshaler:   tracesMarshaler,
 		profilesMarshaler: profilesMarshaler,
-		expectedLogs:      10000,
-		logFile:           logFile,
 	}
 }
 
@@ -108,87 +86,19 @@ func (s *debugExporter) pushMetrics(_ context.Context, md pmetric.Metrics) error
 }
 
 func (s *debugExporter) pushLogs(_ context.Context, ld plog.Logs) error {
-	callNumber := s.exportCallCount.Add(1)
-
-	if callNumber%10 == 0 {
-		s.logger.Warn("Simulating export failure for 10th call", zap.Int64("call_number", callNumber))
-		return fmt.Errorf("simulated export failure on call %d", callNumber)
-	}
-
-	logRecordCount := ld.LogRecordCount()
-
-	for i := 0; i < ld.ResourceLogs().Len(); i++ {
-		resourceLogs := ld.ResourceLogs().At(i)
-		for j := 0; j < resourceLogs.ScopeLogs().Len(); j++ {
-			scopeLogs := resourceLogs.ScopeLogs().At(j)
-			for k := 0; k < scopeLogs.LogRecords().Len(); k++ {
-				logRecord := scopeLogs.LogRecords().At(k)
-				if counter, exists := logRecord.Attributes().Get("test.log.counter"); exists {
-					s.receivedLogs.Store(counter.Int(), true)
-					s.writeLogToFile(logRecord, s.totalLogsCount.Load())
-				}
-			}
-		}
-	}
-
-	currentCount := s.totalLogsCount.Add(int64(logRecordCount))
-	s.logger.Info("Logs body", zap.String("body", ld.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords().At(0).Body().AsString()))
 	s.logger.Info("Logs",
 		zap.Int("resource logs", ld.ResourceLogs().Len()),
-		zap.Int("log records", logRecordCount),
-		zap.Int64("total received", currentCount),
-		zap.Int64("currentCount", currentCount),
-	)
-
-	if currentCount >= s.expectedLogs {
-		uniqueCount := int64(0)
-		var missingLogs []int64
-		receivedCounters := make(map[int64]bool)
-
-		s.receivedLogs.Range(func(key, value interface{}) bool {
-			if counter, ok := key.(int64); ok {
-				receivedCounters[counter] = true
-				uniqueCount++
-			}
-			return true
-		})
-
-		for i := int64(1); i <= s.expectedLogs; i++ {
-			if !receivedCounters[i] {
-				missingLogs = append(missingLogs, i)
-			}
-		}
-
-		successRate := (float64(uniqueCount) / float64(s.expectedLogs)) * 100
-
-		s.logger.Info("SUCCESS RATE REPORT",
-			zap.Int64("expected_logs", s.expectedLogs),
-			zap.Int64("total_received", currentCount),
-			zap.Int64("unique_logs", uniqueCount),
-			zap.Int("missing_count", len(missingLogs)),
-			zap.Float64("success_rate_percent", successRate))
-
-		s.writeReportToFile(s.expectedLogs, currentCount, uniqueCount, int64(len(missingLogs)), successRate, missingLogs)
-
-		if len(missingLogs) > 0 && len(missingLogs) <= 100 {
-			s.logger.Warn("Missing log counters", zap.Int64s("missing", missingLogs))
-		} else if len(missingLogs) > 100 {
-			s.logger.Warn("Too many missing logs to list",
-				zap.Int("missing_count", len(missingLogs)),
-				zap.Int64("first_missing", missingLogs[0]),
-				zap.Int64("last_missing", missingLogs[len(missingLogs)-1]))
-		}
-	}
+		zap.Int("log records", ld.LogRecordCount()))
 
 	if s.verbosity == configtelemetry.LevelBasic {
 		return nil
 	}
 
-	// buf, err := s.logsMarshaler.MarshalLogs(ld)
-	// if err != nil {
-	// 	return err
-	// }
-	// s.logger.Info(string(buf))
+	buf, err := s.logsMarshaler.MarshalLogs(ld)
+	if err != nil {
+		return err
+	}
+	s.logger.Info(string(buf))
 	return nil
 }
 
@@ -208,79 +118,3 @@ func (s *debugExporter) pushProfiles(_ context.Context, pd pprofile.Profiles) er
 	s.logger.Info(string(buf))
 	return nil
 }
-
-func (s *debugExporter) writeLogToFile(logRecord plog.LogRecord, counter int64) {
-	if s.logFile == nil {
-		return
-	}
-
-	s.fileMutex.Lock()
-	defer s.fileMutex.Unlock()
-
-	logLine := fmt.Sprintf("Counter: %d | Body: %s | Severity: %s | Timestamp: %s",
-		counter,
-		logRecord.Body().AsString(),
-		logRecord.SeverityText(),
-		logRecord.Timestamp().String())
-
-	var attrs string
-	logRecord.Attributes().Range(func(k string, v pcommon.Value) bool {
-		attrs += fmt.Sprintf(" | %s: %s", k, v.AsString())
-		return true
-	})
-	logLine += attrs + "\n"
-
-	_, err := s.logFile.WriteString(logLine)
-	if err != nil {
-		s.logger.Error("Failed to write log to file", zap.Error(err))
-	}
-}
-
-func (s *debugExporter) writeReportToFile(expectedLogs, totalReceived, uniqueLogs, missingCount int64, successRate float64, missingLogs []int64) {
-	if s.logFile == nil {
-		return
-	}
-
-	s.fileMutex.Lock()
-	defer s.fileMutex.Unlock()
-
-	report := fmt.Sprintf("\n"+
-		"========================================\n"+
-		"          SUCCESS RATE REPORT          \n"+
-		"========================================\n"+
-		"Expected Logs:        %d\n"+
-		"Total Received:       %d\n"+
-		"Unique Logs:          %d\n"+
-		"Successfully Received: %d\n"+
-		"Missing/Failed:       %d\n"+
-		"Success Rate:         %.2f%%\n"+
-		"========================================\n",
-		expectedLogs, totalReceived, uniqueLogs, uniqueLogs, missingCount, successRate)
-
-	if missingCount > 0 && missingCount <= 100 {
-		report += fmt.Sprintf("\nMissing Log Counters:\n%v\n", missingLogs)
-	} else if missingCount > 100 {
-		report += fmt.Sprintf("\nMissing Logs Count: %d\n", missingCount)
-		report += fmt.Sprintf("First Missing: %d\n", missingLogs[0])
-		report += fmt.Sprintf("Last Missing: %d\n", missingLogs[len(missingLogs)-1])
-	}
-
-	report += "========================================\n\n"
-
-	_, err := s.logFile.WriteString(report)
-	if err != nil {
-		s.logger.Error("Failed to write report to file", zap.Error(err))
-	}
-}
-
-func (s *debugExporter) Shutdown(_ context.Context) error {
-	if s.logFile != nil {
-		s.fileMutex.Lock()
-		defer s.fileMutex.Unlock()
-		if err := s.logFile.Close(); err != nil {
-			s.logger.Error("Failed to close log file", zap.Error(err))
-			return err
-		}
-	}
-	return nil
-}

exporter/debugexporter/factory.go

@@ -86,12 +86,7 @@ func createLogs(ctx context.Context, set exporter.Settings, config component.Con
 		debug.pushLogs,
 		exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
 		exporterhelper.WithTimeout(exporterhelper.TimeoutConfig{Timeout: 0}),
-		exporterhelper.WithShutdown(func(ctx context.Context) error {
-			if err := debug.Shutdown(ctx); err != nil {
-				exporterLogger.Error("Failed to shutdown debug exporter", zap.Error(err))
-			}
-			return otlptext.LoggerSync(exporterLogger)(ctx)
-		}),
+		exporterhelper.WithShutdown(otlptext.LoggerSync(exporterLogger)),
 	)
 }