integration-tests/source-test.go (1)

249-266: Implementation looks good, but consider using a more specific test query.

The Onyphe test implementation follows the same pattern as other test cases, which is good for consistency. However, consider using a more specific query similar to other test cases (e.g., a targeted query like "'app=Grafana'" used in other tests) rather than the generic "google.com" to better validate the specific search capabilities of Onyphe.

sources/agent/onyphe/onyphe.go (4)

15-15: Consider moving URL components to separate constants for better maintainability

The URL template contains several hardcoded values that may require changes in the future. Breaking these into separate constants would improve clarity and maintainability.

-const (
-	URLTemplate = "https://www.onyphe.io/api/v2/search/?q=%s&page=%d&size=10"
-)
+const (
+	BaseURL    = "https://www.onyphe.io/api/v2/search/"
+	DefaultPageSize = 10
+	URLTemplate = BaseURL + "?q=%s&page=%d&size=" + fmt.Sprintf("%d", DefaultPageSize)
+)

---

64-92: Add early return when limit is reached

To avoid unnecessary API calls, check if the limit has been reached before processing each result.

 func (agent *Agent) query(session *sources.Session, onypheRequest OnypheRequest, results chan sources.Result) *OnypheResponse {
 	resp, err := agent.queryURL(session, &onypheRequest)
 	if err != nil {
 		results <- sources.Result{Source: agent.Name(), Error: err}
 		return nil
 	}
 	defer resp.Body.Close()
 
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		results <- sources.Result{Source: agent.Name(), Error: err}
 		return nil
 	}
 
 	var apiResponse OnypheResponse
 	if err := json.Unmarshal(body, &apiResponse); err != nil {
 		results <- sources.Result{Source: agent.Name(), Error: err}
 		return nil
 	}
 
+	// Check if API returned an error code
+	if apiResponse.Error != 0 {
+		results <- sources.Result{Source: agent.Name(), Error: fmt.Errorf("API returned error code: %d", apiResponse.Error)}
+		return nil
+	}
+
 	for _, result := range apiResponse.Results {
 		results <- sources.Result{
 			Source: agent.Name(),
 			IP:     result.IP,
 			Port:   result.Port,
 		}
 	}
 	return &apiResponse
 }

---

18-21: Consider adding comments to struct definition

Adding descriptive comments to the struct definition would improve code documentation and help future maintainers understand the purpose of each field.

+// OnypheRequest contains the parameters needed to query the Onyphe API
 type OnypheRequest struct {
+	// Query is the search term to look for
 	Query string
+	// Page is the pagination parameter (1-based)
 	Page  int
 }

---

23-23: Add struct documentation

The Agent struct is currently undocumented. Adding a comment would improve code clarity.

+// Agent implements the sources.Agent interface for Onyphe
 type Agent struct{}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

sources/agent/onyphe/onyphe.go (1)

29-62: Implement support for query limit parameter

The Query struct from sources/agent.go contains a Limit field, but this implementation doesn't use it. The agent should respect the user's requested limit on the number of results.

 func (agent *Agent) Query(session *sources.Session, query *sources.Query) (chan sources.Result, error) {
 	if session.Keys.OnypheKey == "" {
 		return nil, errors.New("empty Onyphe API key")
 	}
 
 	results := make(chan sources.Result)
 
 	go func() {
 		defer close(results)
 
 		currentPage := 1
 		totalResults := 0
+		maxResults := query.Limit
 
 		for {
 			onypheRequest := &OnypheRequest{
 				Query: query.Query,
 				Page:  currentPage,
 			}
 
 			apiResponse := agent.query(session, *onypheRequest, results)
 			if apiResponse == nil {
 				break
 			}
 
 			totalResults += len(apiResponse.Results)
-			if totalResults >= apiResponse.Total || len(apiResponse.Results) == 0 {
+			if totalResults >= apiResponse.Total || len(apiResponse.Results) == 0 || (maxResults > 0 && totalResults >= maxResults) {
 				break
 			}
 			currentPage++
 		}
 	}()
 
 	return results, nil
 }

sources/agent/onyphe/onyphe.go (3)

15-15: Consider making page size configurable instead of hardcoded

The URL template contains a hardcoded page size of 10. This might be better defined as a configurable constant to allow for flexibility in the number of results per page.

-	URLTemplate = "https://www.onyphe.io/api/v2/search/?q=%s&page=%d&size=10"
+	DefaultPageSize = 10
+	URLTemplate = "https://www.onyphe.io/api/v2/search/?q=%s&page=%d&size=%d"

Then update the queryURL method to use this constant.

---

84-90: Add validation for API response data

The code doesn't validate that the response contains valid data before using it. Consider adding basic validation for the result fields before sending them to the results channel.

 for _, result := range apiResponse.Results {
+	// Skip results with empty IP addresses
+	if result.IP == "" {
+		continue
+	}
+
 	results <- sources.Result{
 		Source: agent.Name(),
 		IP:     result.IP,
 		Port:   result.Port,
 	}
 }

---

94-115: Ensure proper handling of API request errors

Your implementation now handles the basic HTTP status code errors, which is good. However, you might want to add more specific error handling for different status codes to give users better diagnostics.

 if resp.StatusCode != http.StatusOK {
-	return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	switch resp.StatusCode {
+	case http.StatusUnauthorized, http.StatusForbidden:
+		return nil, fmt.Errorf("authentication error: invalid API key or insufficient permissions (status code: %d)", resp.StatusCode)
+	case http.StatusTooManyRequests:
+		return nil, fmt.Errorf("rate limit exceeded (status code: %d)", resp.StatusCode)
+	default:
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro (Legacy)