errors

package

Go to main page

Versions in this module

v0

v0.12.0

Jun 23, 2026

v0.10.0

May 4, 2026

v0.9.0

May 2, 2026

v0.8.1

Feb 18, 2026

v0.8.0

Feb 12, 2026

Changes in this version

+ func IsTemporaryError(err error) bool

+ func WrapWithContext(err error, ctx context.Context, operation string) error

+ func WriteReportJSON(w io.Writer, report *ErrorReport) error

+ func WriteReportText(w io.Writer, report *ErrorReport) error

type BundleError

+ Cause error

+ Code ErrorCode

+ Details map[string]interface{}

+ StackTrace string

+ func (e *BundleError) ToJSON() ([]byte, error)

+ func (e *BundleError) Unwrap() error

+ func (e *BundleError) WithCause(cause error) *BundleError

+ func (e *BundleError) WithDetails(details map[string]interface{}) *BundleError

+ func (e *BundleError) WithRetryInfo(attempt, maxRetries int) *BundleError

+ type CircuitBreaker struct

+ FailureCount int

+ LastFailureTime time.Time

+ State string

+ SuccessCount int

+ Threshold int

+ Timeout time.Duration

+ func NewCircuitBreaker(threshold int, timeout time.Duration) *CircuitBreaker

+ func (cb *CircuitBreaker) CanProceed() bool

+ func (cb *CircuitBreaker) RecordFailure()

+ func (cb *CircuitBreaker) RecordSuccess()

type DefaultErrorHandler

+ Metrics interface{}

+ RecoveryStrategy RecoveryStrategy

+ func NewDefaultErrorHandler() *DefaultErrorHandler

+ func (h *DefaultErrorHandler) SetRecoveryStrategy(strategy RecoveryStrategy)

type DefaultErrorReporter

+ AuditLogger *AuditLogger

+ Writer io.Writer

+ func (r *DefaultErrorReporter) GenerateReport(ctx context.Context, errors []*BundleError) (*ErrorReport, error)

+ func (r *DefaultErrorReporter) Report(ctx context.Context, err *BundleError) error

type EnhancedErrorHandler

+ CircuitBreaker *CircuitBreaker

+ ErrorCategorizer ErrorCategorizer

+ Metrics map[string]int

+ RateLimiter *TokenBucketRateLimiter

+ RecoveryManager *RecoveryManager

+ RetryPolicy *RetryPolicy

+ func (h *EnhancedErrorHandler) GetMetrics() map[string]int

+ func (h *EnhancedErrorHandler) RetryWithPolicy(ctx context.Context, err error) error

type ErrorCategory

+ const SecurityError

+ type ErrorCode string

+ const BackupErrorCode

+ const ConfigurationErrorCode

+ const ConflictErrorCode

+ const ConversionErrorCode

+ const FileSystemErrorCode

+ const ImportErrorCode

+ const NetworkErrorCode

+ const PermissionErrorCode

+ const SecurityErrorCode

+ const UnknownErrorCode

+ const ValidationErrorCode

type ErrorReport

+ GeneratedAt time.Time

+ TotalErrors int

type ErrorReporter

+ GenerateReport func(ctx context.Context, errors []*BundleError) (*ErrorReport, error)

+ Report func(ctx context.Context, err *BundleError) error

+ type ErrorStats struct

+ ByCategory map[string]int

+ ByRecoverability map[string]int

+ BySeverity map[string]int

+ type RetryPolicy struct

+ InitialDelay time.Duration

+ Jitter bool

+ MaxDelay time.Duration

+ MaxRetries int

+ Multiplier float64

+ func NewRetryPolicy(maxRetries int, initialDelay, maxDelay time.Duration) *RetryPolicy

+ type TokenBucketRateLimiter struct

+ Capacity int

+ LastRefill time.Time

+ RefillRate int

+ Tokens int

+ func NewTokenBucketRateLimiter(capacity, refillRate int) *TokenBucketRateLimiter

+ func (rl *TokenBucketRateLimiter) Allow() bool

v0.7.1

Aug 13, 2025

v0.7.0

Aug 13, 2025

v0.6.2-security-analysis

Jul 3, 2025

v0.6.1

Jul 3, 2025

v0.6.0

Jul 3, 2025

v0.5.0

Jun 20, 2025

v0.4.0

Jun 20, 2025

v0.3.0

Jun 20, 2025

v0.2.0

Jun 20, 2025

v0.2.0-stable

Jun 20, 2025

v0.1.1

Jun 20, 2025

v0.1.0

Jun 20, 2025

Changes in this version

+ func GetErrorDetails(err error) map[string]interface

+ func IsRetryableError(err error) bool

+ func WithRetry(ctx context.Context, handler ErrorHandler, fn func() error) error

+ func WithRetryAndContext(ctx context.Context, handler *EnhancedErrorHandler, fn func() error) error

+ func WrapError(err error, message string) error

+ type AuditLogger struct

+ User string

+ Writer io.Writer

+ func NewAuditLogger(writer io.Writer, user string) *AuditLogger

+ func (l *AuditLogger) LogBackupCreated(bundleID, targetDir, backupPath string)

+ func (l *AuditLogger) LogConflict(bundleID string, conflict interface{}, strategy interface{})

+ func (l *AuditLogger) LogEvent(event, component, id string, details map[string]interface{})

+ func (l *AuditLogger) LogEventWithStatus(event, component, id, status string, details map[string]interface{})

+ func (l *AuditLogger) LogFileInstallation(bundleID, filePath string, success bool, details map[string]interface{})

+ func (l *AuditLogger) LogImportComplete(bundleID string, success bool, details map[string]interface{})

+ func (l *AuditLogger) LogImportStart(bundleID, bundlePath string, options map[string]interface{})

+ func (l *AuditLogger) LogImportSummary(bundleID string, stats map[string]interface{})

+ func (l *AuditLogger) LogValidation(bundleID, bundlePath string, level string, success bool, ...)

+ type BackupRecoveryStrategy struct

+ BackupDir string

+ Logger io.Writer

+ func NewBackupRecoveryStrategy(logger io.Writer, backupDir string) *BackupRecoveryStrategy

+ func (s *BackupRecoveryStrategy) CanRecover(err *BundleError) bool

+ func (s *BackupRecoveryStrategy) Recover(ctx context.Context, err *BundleError) (bool, error)

+ type BundleError struct

+ Category ErrorCategory

+ Context map[string]interface{}

+ ErrorID string

+ MaxRetries int

+ Message string

+ Original error

+ Recoverability ErrorRecoverability

+ RetryAttempt int

+ Severity ErrorSeverity

+ Timestamp time.Time

+ func NewBundleError(err error, message string, category ErrorCategory, severity ErrorSeverity, ...) *BundleError

+ func (e *BundleError) Error() string

+ func (e *BundleError) WithContext(key string, value interface{}) *BundleError

+ type ConflictRecoveryStrategy struct

+ Force bool

+ Logger io.Writer

+ func NewConflictRecoveryStrategy(logger io.Writer, force bool) *ConflictRecoveryStrategy

+ func (s *ConflictRecoveryStrategy) CanRecover(err *BundleError) bool

+ func (s *ConflictRecoveryStrategy) Recover(ctx context.Context, err *BundleError) (bool, error)

+ type DefaultErrorCategorizer struct

+ Logger io.Writer

+ func (c *DefaultErrorCategorizer) CategorizeError(err error) (ErrorCategory, ErrorSeverity, ErrorRecoverability)

+ type DefaultErrorHandler struct

+ AdminEmail string

+ AdminNotificationEnabled bool

+ Logger ErrorLogger

+ func (h *DefaultErrorHandler) GetBackoffDuration(ctx context.Context, err *BundleError) time.Duration

+ func (h *DefaultErrorHandler) HandleError(ctx context.Context, err error) (*BundleError, error)

+ func (h *DefaultErrorHandler) LogError(ctx context.Context, err *BundleError)

+ func (h *DefaultErrorHandler) NotifyAdmin(ctx context.Context, err *BundleError) error

+ func (h *DefaultErrorHandler) ShouldRetry(ctx context.Context, err *BundleError) bool

+ type DefaultErrorReporter struct

+ IncludeSystemInfo bool

+ Logger io.Writer

+ NotificationService NotificationService

+ ReportsDir string

+ func (r *DefaultErrorReporter) GenerateErrorReport(ctx context.Context, errors []*BundleError, outputPath string) error

+ func (r *DefaultErrorReporter) GetErrorStatistics(errors []*BundleError) map[string]interface{}

+ func (r *DefaultErrorReporter) ReportError(ctx context.Context, bundleErr *BundleError) error

+ type EmailNotificationService struct

+ Logger io.Writer

+ Recipients []string

+ SMTPPassword string

+ SMTPPort int

+ SMTPServer string

+ SMTPUsername string

+ SenderEmail string

+ func NewEmailNotificationService(recipients []string, senderEmail, smtpServer string, smtpPort int, ...) *EmailNotificationService

+ func (s *EmailNotificationService) SendNotification(ctx context.Context, subject, message string) error

+ type EnhancedErrorHandler struct

+ BackoffBaseSeconds float64

+ BackoffJitterFactor float64

+ BackoffMaxSeconds float64

+ ErrorMetrics *ErrorMetrics

+ MaxRetries int

+ NotificationThreshold ErrorSeverity

+ RetryableCategories map[ErrorCategory]bool

+ func NewEnhancedErrorHandler(logger ErrorLogger) *EnhancedErrorHandler

+ func (h *EnhancedErrorHandler) GetBackoffDuration(ctx context.Context, err *BundleError) time.Duration

+ func (h *EnhancedErrorHandler) GetErrorMetrics() *ErrorMetrics

+ func (h *EnhancedErrorHandler) HandleError(ctx context.Context, err error) (*BundleError, error)

+ func (h *EnhancedErrorHandler) LogError(ctx context.Context, err *BundleError)

+ func (h *EnhancedErrorHandler) NotifyAdmin(ctx context.Context, err *BundleError) error

+ func (h *EnhancedErrorHandler) ResetErrorMetrics()

+ func (h *EnhancedErrorHandler) ShouldRetry(ctx context.Context, err *BundleError) bool

+ type ErrorCategorizer interface

+ CategorizeError func(err error) (ErrorCategory, ErrorSeverity, ErrorRecoverability)

+ func NewErrorCategorizer(logger io.Writer) ErrorCategorizer

+ type ErrorCategory string

+ const BackupError

+ const ConfigurationError

+ const ConflictError

+ const FileSystemError

+ const NetworkError

+ const PermissionError

+ const UnknownError

+ const ValidationError

+ func GetErrorCategory(err error) ErrorCategory

+ type ErrorHandler interface

+ GetBackoffDuration func(ctx context.Context, err *BundleError) time.Duration

+ HandleError func(ctx context.Context, err error) (*BundleError, error)

+ LogError func(ctx context.Context, err *BundleError)

+ NotifyAdmin func(ctx context.Context, err *BundleError) error

+ ShouldRetry func(ctx context.Context, err *BundleError) bool

+ func NewErrorHandler(logger ErrorLogger) ErrorHandler

+ type ErrorLogger interface

+ LogEvent func(event, component, id string, details map[string]interface{})

+ LogEventWithStatus func(event, component, id, status string, details map[string]interface{})

+ type ErrorMetrics struct

+ ErrorsByCategory map[ErrorCategory]int

+ ErrorsBySeverity map[ErrorSeverity]int

+ RecoveredErrors int

+ RetryAttempts int

+ SuccessfulRetries int

+ TotalErrors int

+ UnrecoveredErrors int

+ type ErrorRecoverability string

+ const NonRecoverableError

+ const RecoverableError

+ type ErrorReport struct

+ Errors []*BundleError

+ ReportID string

+ Statistics map[string]interface{}

+ SystemInfo map[string]interface{}

+ Timestamp time.Time

+ type ErrorReporter interface

+ GenerateErrorReport func(ctx context.Context, errors []*BundleError, outputPath string) error

+ GetErrorStatistics func(errors []*BundleError) map[string]interface{}

+ ReportError func(ctx context.Context, err *BundleError) error

+ func NewErrorReporter(logger io.Writer, reportsDir string) ErrorReporter

+ type ErrorSeverity string

+ const CriticalSeverity

+ const HighSeverity

+ const LowSeverity

+ const MediumSeverity

+ func GetErrorSeverity(err error) ErrorSeverity

+ type FileSystemRecoveryStrategy struct

+ Logger io.Writer

+ func NewFileSystemRecoveryStrategy(logger io.Writer) *FileSystemRecoveryStrategy

+ func (s *FileSystemRecoveryStrategy) CanRecover(err *BundleError) bool

+ func (s *FileSystemRecoveryStrategy) Recover(ctx context.Context, err *BundleError) (bool, error)

+ type NetworkRecoveryStrategy struct

+ Logger io.Writer

+ MaxRetries int

+ func NewNetworkRecoveryStrategy(logger io.Writer, maxRetries int) *NetworkRecoveryStrategy

+ func (s *NetworkRecoveryStrategy) CanRecover(err *BundleError) bool

+ func (s *NetworkRecoveryStrategy) Recover(ctx context.Context, err *BundleError) (bool, error)

+ type NotificationService interface

+ SendNotification func(ctx context.Context, subject, message string) error

+ type RecoveryManager struct

+ AuditLogger *AuditLogger

+ Logger io.Writer

+ Strategies []RecoveryStrategy

+ func NewRecoveryManager(logger io.Writer, auditLogger *AuditLogger) *RecoveryManager

+ func (m *RecoveryManager) AddStrategy(strategy RecoveryStrategy)

+ func (m *RecoveryManager) AttemptRecovery(ctx context.Context, err *BundleError) (bool, error)

+ type RecoveryStrategy interface

+ CanRecover func(err *BundleError) bool

+ Recover func(ctx context.Context, err *BundleError) (bool, error)

+ type SlackNotificationService struct

+ Channel string

+ Logger io.Writer

+ Username string

+ WebhookURL string

+ func NewSlackNotificationService(webhookURL, channel, username string, logger io.Writer) *SlackNotificationService

+ func (s *SlackNotificationService) SendNotification(ctx context.Context, subject, message string) error

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL