War Story: I Ditched a High-Paying Job for Open Source Work and Cut Income 60%

package main

import (
    \"context\"
    \"fmt\"
    \"io\"
    \"net/http\"
    \"time\"

    \"github.com/gogo/protobuf/proto\"
    \"github.com/prometheus/prometheus/prompb\"
    \"github.com/rs/zerolog\"
    \"github.com/rs/zerolog/log\"
)

// RemoteWriteReceiver handles Prometheus remote write requests, validates payloads,
// and writes metrics to a local TSDB instance. This implementation includes
// full error handling, request validation, and structured logging.
type RemoteWriteReceiver struct {
    tsdbClient *TSDBClient
    validator  *MetricValidator
    logger     zerolog.Logger
    timeout    time.Duration
}

// MetricValidator validates incoming Prometheus metric labels and values against
// a set of configurable rules to prevent bad data from entering the TSDB.
type MetricValidator struct {
    allowedNamespaces []string
    maxLabelLength    int
}

// TSDBClient is a stub for a real TSDB write client, e.g., Prometheus or VictoriaMetrics.
type TSDBClient struct {
    writeEndpoint string
    logger        zerolog.Logger
}

// NewRemoteWriteReceiver initializes a new receiver with the given dependencies.
// Returns an error if any dependencies are nil.
func NewRemoteWriteReceiver(
    tsdbClient *TSDBClient,
    validator *MetricValidator,
    timeout time.Duration,
) (*RemoteWriteReceiver, error) {
    if tsdbClient == nil {
        return nil, fmt.Errorf(\"tsdbClient cannot be nil\")
    }
    if validator == nil {
        return nil, fmt.Errorf(\"validator cannot be nil\")
    }
    if timeout <= 0 {
        return nil, fmt.Errorf(\"timeout must be positive\")
    }
    return &RemoteWriteReceiver{
        tsdbClient: tsdbClient,
        validator:  validator,
        logger:     log.With().Str(\"component\", \"remote_write_receiver\").Logger(),
        timeout:    timeout,
    }, nil
}

// HandleRemoteWrite processes incoming HTTP requests from Prometheus remote write.
// It validates the protobuf payload, checks metrics against validation rules,
// and writes valid metrics to the TSDB.
func (r *RemoteWriteReceiver) HandleRemoteWrite(w http.ResponseWriter, req *http.Request) {
    ctx, cancel := context.WithTimeout(req.Context(), r.timeout)
    defer cancel()

    // Validate HTTP method
    if req.Method != http.MethodPost {
        r.logger.Warn().Str(\"method\", req.Method).Msg(\"invalid HTTP method\")
        http.Error(w, \"only POST requests are allowed\", http.StatusMethodNotAllowed)
        return
    }

    // Read request body with size limit to prevent OOM attacks
    body, err := io.ReadAll(io.LimitReader(req.Body, 10<<20)) // 10MB limit
    if err != nil {
        r.logger.Error().Err(err).Msg(\"failed to read request body\")
        http.Error(w, \"failed to read request body\", http.StatusBadRequest)
        return
    }
    defer req.Body.Close()

    // Unmarshal protobuf payload
    var writeReq prompb.WriteRequest
    if err := proto.Unmarshal(body, &writeReq); err != nil {
        r.logger.Error().Err(err).Msg(\"failed to unmarshal protobuf payload\")
        http.Error(w, \"invalid protobuf payload\", http.StatusBadRequest)
        return
    }

    // Validate all metrics in the request
    validMetrics := make([]*prompb.TimeSeries, 0, len(writeReq.Timeseries))
    for _, ts := range writeReq.Timeseries {
        if err := r.validator.ValidateTimeSeries(ts); err != nil {
            r.logger.Warn().Err(err).Msg(\"invalid timeseries, skipping\")
            continue
        }
        validMetrics = append(validMetrics, ts)
    }

    // Check if we have any valid metrics to write
    if len(validMetrics) == 0 {
        r.logger.Warn().Msg(\"no valid metrics in request\")
        w.WriteHeader(http.StatusNoContent)
        return
    }

    // Write valid metrics to TSDB
    if err := r.tsdbClient.WriteTimeSeries(ctx, validMetrics); err != nil {
        r.logger.Error().Err(err).Msg(\"failed to write metrics to TSDB\")
        http.Error(w, \"failed to write metrics\", http.StatusInternalServerError)
        return
    }

    // Return success response
    w.WriteHeader(http.StatusAccepted)
    r.logger.Info().Int(\"valid_metrics\", len(validMetrics)).Int(\"total_metrics\", len(writeReq.Timeseries)).Msg(\"successfully processed remote write request\")
}

// ValidateTimeSeries checks a single Prometheus TimeSeries against validation rules.
func (v *MetricValidator) ValidateTimeSeries(ts *prompb.TimeSeries) error {
    if ts == nil {
        return fmt.Errorf(\"timeseries is nil\")
    }
    // Check label length
    for _, label := range ts.Labels {
        if len(label.Value) > v.maxLabelLength {
            return fmt.Errorf(\"label %s value exceeds max length %d\", label.Name, v.maxLabelLength)
        }
    }
    // Check allowed namespaces if configured
    if len(v.allowedNamespaces) > 0 {
        namespace := \"\"
        for _, label := range ts.Labels {
            if label.Name == \"__namespace__\" {
                namespace = label.Value
                break
            }
        }
        allowed := false
        for _, ns := range v.allowedNamespaces {
            if namespace == ns {
                allowed = true
                break
            }
        }
        if !allowed {
            return fmt.Errorf(\"namespace %s is not allowed\", namespace)
        }
    }
    return nil
}

// WriteTimeSeries writes a slice of TimeSeries to the TSDB. Stub implementation.
func (t *TSDBClient) WriteTimeSeries(ctx context.Context, metrics []*prompb.TimeSeries) error {
    // In a real implementation, this would send metrics to the TSDB write endpoint
    t.logger.Info().Int(\"metric_count\", len(metrics)).Msg(\"writing metrics to TSDB\")
    return nil
}

import os
import sys
import time
from typing import List, Dict
import github
from github import Github, Issue, PullRequest
from github.GithubException import GithubException

# Configuration constants
GITHUB_TOKEN = os.environ.get(\"GITHUB_TOKEN\")
if not GITHUB_TOKEN:
    print(\"Error: GITHUB_TOKEN environment variable is not set\", file=sys.stderr)
    sys.exit(1)

REPO_NAME = \"open-telemetry/opentelemetry-go\"
TRIAGE_LABELS = [\"needs-triage\", \"bug\", \"enhancement\", \"documentation\", \"question\"]
STALE_DAYS = 30
STALE_LABEL = \"stale\"

class IssueTriager:
    \"\"\"Automates triage of GitHub issues for the OpenTelemetry Go repository.\"\"\"

    def __init__(self, github_client: Github, repo_name: str):
        \"\"\"Initialize the triager with a Github client and repo name.

        Args:
            github_client: Authenticated Github client instance.
            repo_name: Full name of the repository (e.g., \"owner/repo\").

        Raises:
            ValueError: If repo_name is empty or github_client is None.
            GithubException: If the repository is not found.
        \"\"\"
        if not github_client:
            raise ValueError(\"github_client cannot be None\")
        if not repo_name:
            raise ValueError(\"repo_name cannot be empty\")

        self.client = github_client
        try:
            self.repo = self.client.get_repo(repo_name)
        except GithubException as e:
            raise GithubException(f\"Failed to fetch repo {repo_name}: {e}\") from e
        self.triage_labels = set(TRIAGE_LABELS)
        self.stale_days = STALE_DAYS
        self.stale_label = STALE_LABEL

    def get_open_issues(self) -> List[Issue.Issue]:
        \"\"\"Fetch all open issues that do not have any labels.

        Returns:
            List of unlabeled open issues.

        Raises:
            GithubException: If fetching issues fails.
        \"\"\"
        try:
            # Get all open issues, exclude pull requests
            issues = self.repo.get_issues(state=\"open\", labels=[])
            # Filter out pull requests (Github API returns PRs as issues)
            return [issue for issue in issues if not issue.pull_request]
        except GithubException as e:
            print(f\"Error fetching open issues: {e}\", file=sys.stderr)
            raise

    def classify_issue(self, issue: Issue.Issue) -> str:
        \"\"\"Classify an issue based on its title and body content.

        Args:
            issue: Github issue instance.

        Returns:
            Label to apply: \"bug\", \"enhancement\", \"documentation\", \"question\", or \"needs-triage\".
        \"\"\"
        title = issue.title.lower()
        body = issue.body.lower() if issue.body else \"\"

        if any(keyword in title or keyword in body for keyword in [\"crash\", \"panic\", \"error\", \"bug\"]):
            return \"bug\"
        if any(keyword in title or keyword in body for keyword in [\"feature\", \"add\", \"enhancement\", \"request\"]):
            return \"enhancement\"
        if any(keyword in title or keyword in body for keyword in [\"docs\", \"documentation\", \"readme\"]):
            return \"documentation\"
        if any(keyword in title or keyword in body for keyword in [\"question\", \"how to\", \"help\"]):
            return \"question\"
        return \"needs-triage\"

    def apply_label(self, issue: Issue.Issue, label: str) -> None:
        \"\"\"Apply a label to an issue, handling rate limits and errors.

        Args:
            issue: Github issue instance.
            label: Label to apply.

        Raises:
            GithubException: If applying label fails.
        \"\"\"
        try:
            # Check if label already exists on issue
            existing_labels = {lbl.name for lbl in issue.labels}
            if label in existing_labels:
                return
            issue.add_to_labels(label)
            print(f\"Applied label '{label}' to issue #{issue.number}\")
        except GithubException as e:
            # Handle rate limiting
            if e.status == 403 and \"rate limit\" in str(e).lower():
                print(\"Rate limit hit, sleeping for 60 seconds\", file=sys.stderr)
                time.sleep(60)
                self.apply_label(issue, label)  # Retry after sleep
            else:
                print(f\"Error applying label to issue #{issue.number}: {e}\", file=sys.stderr)
                raise

    def mark_stale_issues(self) -> None:
        \"\"\"Mark issues that have been open for more than STALE_DAYS with no activity as stale.\"\"\"
        try:
            issues = self.repo.get_issues(state=\"open\")
            current_time = time.time()
            for issue in issues:
                if any(lbl.name == self.stale_label for lbl in issue.labels):
                    continue  # Already stale
                last_updated = issue.updated_at.timestamp()
                days_open = (current_time - last_updated) / (60 * 60 * 24)
                if days_open > self.stale_days:
                    self.apply_label(issue, self.stale_label)
        except GithubException as e:
            print(f\"Error marking stale issues: {e}\", file=sys.stderr)
            raise

    def run_triage(self) -> None:
        \"\"\"Run the full triage process: fetch unlabeled issues, classify, apply labels.\"\"\"
        print(f\"Starting triage for {REPO_NAME}\")
        try:
            unlabeled_issues = self.get_open_issues()
            print(f\"Found {len(unlabeled_issues)} unlabeled issues\")
            for issue in unlabeled_issues:
                label = self.classify_issue(issue)
                self.apply_label(issue, label)
            self.mark_stale_issues()
            print(\"Triage completed successfully\")
        except GithubException as e:
            print(f\"Triage failed: {e}\", file=sys.stderr)
            sys.exit(1)

if __name__ == \"__main__\":
    try:
        gh_client = Github(GITHUB_TOKEN)
        triager = IssueTriager(gh_client, REPO_NAME)
        triager.run_triage()
    except Exception as e:
        print(f\"Fatal error: {e}\", file=sys.stderr)
        sys.exit(1)

import { Span, Trace } from \"@opentelemetry/api\";
import { ValidationError } from \"./errors\";
import { Logger } from \"./logger\";

// Configuration for trace validation
const MAX_SPAN_COUNT = 1000;
const MAX_SPAN_NAME_LENGTH = 256;
const REQUIRED_ATTRIBUTES = [\"service.name\", \"deployment.environment\"];

/**
 * Validates a complete OpenTelemetry trace against compliance rules.
 * Ensures span counts are within limits, span names are valid, and required
 * attributes are present on root spans.
 */
export class TraceValidator {
  private logger: Logger;

  constructor(logger: Logger) {
    if (!logger) {
      throw new ValidationError(\"Logger must be provided to TraceValidator\");
    }
    this.logger = logger;
  }

  /**
   * Validate a single trace.
   * @param trace - The OpenTelemetry trace to validate.
   * @throws {ValidationError} If the trace is invalid.
   */
  validateTrace(trace: Trace): void {
    if (!trace) {
      throw new ValidationError(\"Trace cannot be null or undefined\");
    }
    if (!Array.isArray(trace.spans)) {
      throw new ValidationError(\"Trace must contain a spans array\");
    }

    // Check span count limit
    if (trace.spans.length > MAX_SPAN_COUNT) {
      const errorMsg = `Trace has ${trace.spans.length} spans, max allowed is ${MAX_SPAN_COUNT}`;
      this.logger.error(errorMsg, { traceId: trace.traceId });
      throw new ValidationError(errorMsg);
    }

    // Validate each span in the trace
    for (const span of trace.spans) {
      this.validateSpan(span, trace.traceId);
    }

    // Validate root span (first span in trace) has required attributes
    const rootSpan = trace.spans[0];
    if (rootSpan) {
      this.validateRootSpan(rootSpan, trace.traceId);
    }
  }

  /**
   * Validate a single span.
   * @param span - The span to validate.
   * @param traceId - The trace ID for logging context.
   * @throws {ValidationError} If the span is invalid.
   */
  private validateSpan(span: Span, traceId: string): void {
    if (!span) {
      throw new ValidationError(\"Span cannot be null or undefined\");
    }
    if (!span.spanId) {
      const errorMsg = \"Span is missing spanId\";
      this.logger.error(errorMsg, { traceId });
      throw new ValidationError(errorMsg);
    }
    if (!span.traceId) {
      const errorMsg = \"Span is missing traceId\";
      this.logger.error(errorMsg, { traceId, spanId: span.spanId });
      throw new ValidationError(errorMsg);
    }
    if (span.traceId !== traceId) {
      const errorMsg = `Span traceId ${span.traceId} does not match trace traceId ${traceId}`;
      this.logger.error(errorMsg, { traceId, spanId: span.spanId });
      throw new ValidationError(errorMsg);
    }

    // Validate span name length
    if (span.name.length > MAX_SPAN_NAME_LENGTH) {
      const errorMsg = `Span name length ${span.name.length} exceeds max ${MAX_SPAN_NAME_LENGTH}`;
      this.logger.error(errorMsg, { traceId, spanId: span.spanId });
      throw new ValidationError(errorMsg);
    }

    // Validate span start and end times
    if (span.startTime && span.endTime) {
      if (span.endTime < span.startTime) {
        const errorMsg = \"Span end time is before start time\";
        this.logger.error(errorMsg, { traceId, spanId: span.spanId });
        throw new ValidationError(errorMsg);
      }
    }
  }

  /**
   * Validate the root span has all required attributes.
   * @param rootSpan - The root span to validate.
   * @param traceId - The trace ID for logging context.
   * @throws {ValidationError} If required attributes are missing.
   */
  private validateRootSpan(rootSpan: Span, traceId: string): void {
    const spanAttributes = rootSpan.attributes || {};
    const missingAttributes = REQUIRED_ATTRIBUTES.filter(
      (attr) => !spanAttributes[attr]
    );

    if (missingAttributes.length > 0) {
      const errorMsg = `Root span missing required attributes: ${missingAttributes.join(\", \")}`;
      this.logger.error(errorMsg, { traceId, spanId: rootSpan.spanId });
      throw new ValidationError(errorMsg);
    }
  }

  /**
   * Batch validate multiple traces, returning a list of validation errors.
   * @param traces - Array of traces to validate.
   * @returns Array of validation errors, empty if all traces are valid.
   */
  batchValidateTraces(traces: Trace[]): ValidationError[] {
    const errors: ValidationError[] = [];
    for (const trace of traces) {
      try {
        this.validateTrace(trace);
      } catch (err) {
        if (err instanceof ValidationError) {
          errors.push(err);
        } else {
          errors.push(new ValidationError(`Unexpected error validating trace: ${err.message}`));
        }
      }
    }
    return errors;
  }
}

// Example usage
const logger = new Logger(\"trace-validator\");
const validator = new TraceValidator(logger);
try {
  const sampleTrace = {
    traceId: \"4bf92f3577b34da6a3ce929d0e0e4736\",
    spans: [
      {
        spanId: \"00f067aa0ba902b7\",
        traceId: \"4bf92f3577b34da6a3ce929d0e0e4736\",
        name: \"GET /api/users\",
        startTime: Date.now(),
        endTime: Date.now() + 100,
        attributes: {
          \"service.name\": \"user-service\",
          \"deployment.environment\": \"production\",
        },
      },
    ],
  };
  validator.validateTrace(sampleTrace);
  console.log(\"Sample trace is valid\");
} catch (err) {
  console.error(\"Trace validation failed:\", err.message);
}

gh sponsors list --user yourusername --json login,monthlyPledge

{
  \"extends\": [\"config:base\", \"schedule:nonOfficeHours\"],
  \"packageRules\": [
    {
      \"matchPackagePatterns\": [\"*\"],
      \"matchUpdateTypes\": [\"minor\", \"patch\"],
      \"automerge\": true
    }
  ],
  \"go\": {
    \"enabled\": true
  }
}

sum(rate(github_release_download_count{repo=\"yourusername/yourrepo\"}[30d])) * 30