package main import ( "context""encoding/json""log""github.com/vxcontrol/cloud/models""github.com/vxcontrol/cloud/sdk""github.com/vxcontrol/cloud/system""github.com/sirupsen/logrus" ) typeClientstruct{UpdatesCheck sdk.CallReqBytesRespBytesReportError sdk.CallReqBytesRespBytes } funcmain(){varclientClient// Configure endpointsconfigs:= []sdk.CallConfig{{Calls: []any{&client.UpdatesCheck}, Host: "update.pentagi.com", Name: "updates_check", Path: "/api/v1/updates/check", Method: sdk.CallMethodPOST, },{Calls: []any{&client.ReportError}, Host: "support.pentagi.com", Name: "error_report", Path: "/api/v1/errors/report", Method: sdk.CallMethodPOST, }, } // Initialize SDKerr:=sdk.Build(configs, sdk.WithClient("MySecTool", "1.0.0"), sdk.WithInstallationID(system.GetInstallationID()), sdk.WithLogger(sdk.WrapLogrus(logrus.StandardLogger())), sdk.WithLicenseKey("XXXX-XXXX-XXXX-XXXX"), ) iferr!=nil{log.Fatal("SDK initialization failed:", err) } // Check for updatesupdateReq:= models.CheckUpdatesRequest{InstallerVersion: "1.0.0", InstallerOS: models.OSTypeLinux, InstallerArch: models.ArchTypeAMD64, } data, _:=json.Marshal(updateReq) response, err:=client.UpdatesCheck(context.Background(), data) iferr!=nil{log.Fatal("Update check failed:", err) } varupdateResp models.CheckUpdatesResponsejson.Unmarshal(response, &updateResp) log.Printf("Available updates: %+v", updateResp.Updates) }

import"github.com/vxcontrol/cloud/models"// Check for component updatesupdateReq:= models.CheckUpdatesRequest{InstallerVersion: "1.0.0", InstallerOS: models.OSTypeLinux, InstallerArch: models.ArchTypeAMD64, Components: []models.ComponentInfo{{Component: models.ComponentTypePentagi, Status: models.ComponentStatusRunning, Version: &[]string{"1.2.0"}[0], }, }, } data, _:=json.Marshal(updateReq) response, err:=client.UpdatesCheck(ctx, data) varupdateResp models.CheckUpdatesResponsejson.Unmarshal(response, &updateResp)

// Report an error for analysiserrorReq:= models.SupportErrorRequest{Component: models.ComponentTypePentagi, Version: "1.0.0", OS: models.OSTypeLinux, Arch: models.ArchTypeAMD64, ErrorDetails: map[string]any{"error_type": "connection_timeout", "message": "Failed to connect to target", "context": map[string]string{"target": "192.168.1.1", "port": "443"}, }, } data, _:=json.Marshal(errorReq) response, err:=client.ReportError(ctx, data)

// Get package informationpackageReq:= models.PackageInfoRequest{Component: models.ComponentTypePentagi, Version: "1.0.0", OS: models.OSTypeLinux, Arch: models.ArchTypeAMD64, } // Validate package integrity with signaturessignature:=models.SignatureValue("base64-encoded-signature") fileData, _:=os.ReadFile("package.tar.gz") iferr:=signature.ValidateData(fileData); err!=nil{log.Fatal("Package signature validation failed:", err) }

// Create support issueissueReq:= models.SupportIssueRequest{Component: models.ComponentTypeEngine, Version: "2.0.0", OS: models.OSTypeDarwin, Arch: models.ArchTypeARM64, ErrorDetails: "Scanner fails to detect specific vulnerability patterns", Logs: []models.SupportLogs{{Component: models.ComponentTypeEngine, Logs: []string{"ERROR: Pattern matching timeout", "WARN: Memory usage high"}, }, }, } // Investigate with AI assistanceinvestigationReq:= models.SupportInvestigationRequest{IssueID: receivedIssueID, UserInput: "The scanner works fine with other patterns but fails on this specific CVE", }

err:=sdk.Build(configs, // Required: Client identificationsdk.WithClient("MyApp", "1.0.0"), // Optional: Premium featuressdk.WithLicenseKey("XXXX-XXXX-XXXX-XXXX"), // Optional: Performance tuningsdk.WithPowTimeout(30*time.Second), sdk.WithMaxRetries(3), )

// Custom transport for proxies/certificatestransport:=sdk.DefaultTransport() transport.TLSClientConfig=&tls.Config{MinVersion: tls.VersionTLS12, // custom certificate validation } transport.Proxy=http.ProxyURL(proxyURL) // Custom structured logginglogger:=logrus.New() logger.SetLevel(logrus.InfoLevel) err:=sdk.Build(configs, sdk.WithTransport(transport), sdk.WithLogger(sdk.WrapLogrus(logger)), sdk.WithInstallationID(system.GetInstallationID()), )

// Temporary errors (automatically retried):// - Server overload (sdk.ErrBadGateway, sdk.ErrServerInternal)// - Rate limits (sdk.ErrTooManyRequests, sdk.ErrTooManyRequestsRPM)// - PoW timeouts (sdk.ErrExperimentTimeout)// Fatal errors (no retry):// - Invalid requests (sdk.ErrBadRequest, sdk.ErrForbidden)// - Missing resources (sdk.ErrNotFound)// - Long-term limits (sdk.ErrTooManyRequestsRPH, sdk.ErrTooManyRequestsRPD)

data, err:=api.QueryThreats(ctx, []byte(threatQuery)) iferr!=nil{switch{caseerrors.Is(err, sdk.ErrTooManyRequestsRPM): // Wait and retry with exponential backofftime.Sleep(60*time.Second) caseerrors.Is(err, sdk.ErrForbidden): // Check license validity or authenticationlog.Error("access denied - verify license key") caseerrors.Is(err, sdk.ErrExperimentTimeout): // Increase PoW timeout for slower systems// Reconfigure with sdk.WithPowTimeout(60*time.Second)default: log.Error("unexpected error:", err) } }

// Reuse SDK instances across requestserr:=sdk.Build(configs, options...) // Use streaming for large datareader, err:=api.ProcessLargeDataset(ctx, dataStream, dataSize) // Configure connection pooling for high throughputtransport:=sdk.DefaultTransport() transport.MaxConnsPerHost=500sdk.WithTransport(transport)

// Minimum production setuperr:=sdk.Build(configs, sdk.WithClient("YourApp", version), // Required: Identificationsdk.WithLicenseKey(licenseKey), // Optional: Authenticationsdk.WithLogger(productionLogger), // Recommended: Monitoring )

// Custom logger for metrics collectiontypeMetricsLoggerstruct{*logrus.LoggermetricsMetricsCollector } func (m*MetricsLogger) WithError(errerror) sdk.Entry{// Track error rates by typem.metrics.IncrementErrorCounter(err) returnm.Logger.WithError(err) } // Integrationlogger:=&MetricsLogger{Logger: logrus.New(), metrics: yourMetrics} sdk.WithLogger(logger)

// Integrate update checking into security toolsfunccheckSecurityToolUpdates(components []models.ComponentInfo) error{updateReq:= models.CheckUpdatesRequest{InstallerVersion: getCurrentVersion(), InstallerOS: getCurrentOS(), InstallerArch: getCurrentArch(), Components: components, } data, _:=json.Marshal(updateReq) response, err:=client.UpdatesCheck(context.Background(), data) iferr!=nil{returnerr } varupdateResp models.CheckUpdatesResponsejson.Unmarshal(response, &updateResp) for_, update:=rangeupdateResp.Updates{ifupdate.HasUpdate{log.Printf("Update available for %s: %s -> %s", update.Stack, *update.CurrentVersion, *update.LatestVersion) } } returnnil }

// Integrate error reporting into application error handlingfuncreportSecurityToolError(component models.ComponentType, errerror) error{errorReq:= models.SupportErrorRequest{Component: component, Version: getComponentVersion(component), OS: getCurrentOS(), Arch: getCurrentArch(), ErrorDetails: map[string]any{"error_message": err.Error(), "stack_trace": getStackTrace(), "context": getCurrentContext(), }, } data, _:=json.Marshal(errorReq) _, reportErr:=client.ReportError(context.Background(), data) returnreportErr }

// Validate downloaded packages before installationfuncvalidatePackageIntegrity(packagePath, signatureStrstring) error{signature:=models.SignatureValue(signatureStr) // Validate file signatureiferr:=signature.ValidateFile(packagePath); err!=nil{returnfmt.Errorf("package signature validation failed: %w", err) } log.Println("Package integrity verified successfully") returnnil } // Validate data integrity in memoryfuncvalidateDataIntegrity(data []byte, signatureStrstring) error{signature:=models.SignatureValue(signatureStr) iferr:=signature.ValidateData(data); err!=nil{returnfmt.Errorf("data signature validation failed: %w", err) } returnnil }

// Connect to different service clusterstypeFullClientstruct{UpdatesCheck sdk.CallReqBytesRespBytesErrorReport sdk.CallReqBytesRespBytesPackageInfo sdk.CallReqBytesRespBytesSupportIssue sdk.CallReqBytesRespBytes } configs:= []sdk.CallConfig{{Calls: []any{&client.UpdatesCheck}, Host: "update.pentagi.com", Name: "check_updates", Path: "/api/v1/updates/check", Method: sdk.CallMethodPOST, },{Calls: []any{&client.ErrorReport}, Host: "support.pentagi.com", Name: "error_report", Path: "/api/v1/errors/report", Method: sdk.CallMethodPOST, },{Calls: []any{&client.PackageInfo}, Host: "update.pentagi.com", Name: "package_info", Path: "/api/v1/packages/info", Method: sdk.CallMethodPOST, }, }

// Configure timeouts for different operation typeserr:=sdk.Build(configs, sdk.WithPowTimeout(30*time.Second), // For slower systems (max 60s, default 10s)sdk.WithMaxRetries(5), // For rate limiting and network issuessdk.WithTransport(customTransport), // Custom HTTP configuration ) // Per-request timeoutsctx, cancel:=context.WithTimeout(context.Background(), 2*time.Minute) defercancel() response, err:=client.UpdatesCheck(ctx, requestData)