libprobe

type BaseResult[T any] struct {
	Target    Target[T]
	Success   bool
	Err       error
	Duration  time.Duration
	StartTime time.Time
	EndTime   time.Time
}

type HTTPClientTrace struct {
	// contains filtered or unexported fields
}

type HTTPExtention struct {
	// HTTP-specific parameters
	Method  string      // HTTP method (GET, POST, etc.)
	Headers http.Header // Request headers
	Body    []byte      // Request body
}

type HTTPProber struct{}

type HTTPResult struct {
	BaseResult[HTTPExtention]
	DNSResolveTime   time.Duration // DNS lookup time
	ConnectTime      time.Duration // TCP connection time
	TLSHandshakeTime time.Duration // TLS handshake time
	TTFB             time.Duration // Time to first byte
	TransferTime     time.Duration // Content transfer time
	StatusCode       int           // HTTP status code
	ResponseSize     int           // Response body size in bytes
	ResponseBody     []byte        // Raw response body
}

type HTTPTraceInfo struct {
	// FailedStep is the step name that failed while requesting.
	FailedStep string

	// DNSLookup is a duration that transport took to perform
	// DNS lookup.
	DNSLookup time.Duration

	// ConnTime is a duration that took to obtain a successful connection.
	ConnTime time.Duration

	// TCPConnTime is a duration that took to obtain the TCP connection.
	TCPConnTime time.Duration

	// TLSHandshake is a duration that TLS handshake took place.
	TLSHandshake time.Duration

	// RequestSendingTime is a duration that request wrote takes(may contains multiple retries).
	RequestSendingTime time.Duration

	// TTFB(TimeToFirstByte) is a duration that server took to respond first byte.
	TTFB time.Duration

	// ResponseTime is a duration since first response byte from server to
	// request completion.
	ResponseTime time.Duration

	// TotalTime is a duration that total request took end-to-end.
	TotalTime time.Duration

	// IsConnReused is whether this connection has been previously
	// used for another HTTP request.
	IsConnReused bool

	// IsConnWasIdle is whether this connection was obtained from an
	// idle pool.
	IsConnWasIdle bool

	// ConnIdleTime is a duration how long the connection was previously
	// idle, if IsConnWasIdle is true.
	ConnIdleTime time.Duration

	// RemoteAddr returns the remote network address.
	RemoteAddr net.Addr

	// Timestamps
	RequestStartAt      time.Time
	FirstResponseByteAt time.Time
}

type ICMPExtention struct {
	TTL      int    // Time To Live value
	SourceIP string // Source IP address for the probe
	EnableV6 bool   // Whether to use IPv6
	Sequence int    // ICMP sequence number
	Size     int    // ICMP packet size
}

type ICMPProber struct {
	// contains filtered or unexported fields
}

type ICMPResult struct {
	BaseResult[ICMPExtention]
	Address  string
	Sequence int
	Size     int
}

type IcmpID struct {
	// contains filtered or unexported fields
}

type MTRExtention struct {
	ICMPExtention
	MaxHops    int  // Maximum number of hops to probe
	ResolvePtr bool // Whether to resolve PTR records
}

type MTRHop struct {
	TTL       int           // Time To Live value
	Address   string        // IP address of the hop
	Hostname  string        // DNS name (if resolvable)
	Loss      float64       // Packet loss percentage
	LastRTT   time.Duration // Last Round Trip Time
	AvgRTT    time.Duration // Average Round Trip Time
	BestRTT   time.Duration // Best Round Trip Time
	WorstRTT  time.Duration // Worst Round Trip Time
	StdDevRTT time.Duration // Standard deviation of RTT
	Sent      int           // Number of packets sent
	Received  int           // Number of packets received
}

type MTRProber struct {
	// contains filtered or unexported fields
}

type MTRResult struct {
	BaseResult[MTRExtention]
	Hops []MTRHop // All hops in the route
}

type Prober[T any] interface {
	Kind() string
	Probe(target Target[T]) (Result[T], error)
}

type Result[T any] interface {
	// RTT returns the round-trip time of the probe
	RTT() time.Duration
	// String returns a human-readable representation of the result
	String() string
	// GetTarget returns the original probe target
	GetTarget() Target[T]
	// IsSuccess returns whether the probe was successful
	IsSuccess() bool
	// Error returns any error that occurred during probing
	Error() error
}

type TCPExtention struct {
	// Port specifies the TCP port to connect to
	Port int
}

type TCPProber struct{}

type TCPResult struct {
	BaseResult[TCPExtention]
	ConnectTime time.Duration
}

type Target[T any] struct {
	// Address can be an IP, IP:Port or URL
	Address string
	// Timeout for the entire probe operation
	Timeout time.Duration
	// Interval between multiple probes
	Interval time.Duration
	// Number of probes to send
	Count int

	// Extension parameters specific to each probe type
	Extention T

	// DEPRECATED: These fields will be moved to respective Extensions
	RequestMethod string
	Headers       http.Header
	Body          io.Reader
}