מה יכול להיות סיבה לשגיאה 1200 חוזרת ונשנית באתר שמוגש דרך קלאודפלייר?

[ע"ה דכו"ע]

אני העברתי בימים האחרונים אתר שמשתמש בSSE (לשליחת מתמשכת של מידע מהשרת) דרך פרוקסי של קלאודפלייר, ונהיה אחרי כמה שעות המון פעמים שגיאה 1200 בכניסה, שזה אומר על פי התיעוד שיש מידי הרבה בקשות שמחכות בתור מהפרוקסי לשרת המקורי.

השאלה למה זה קורה, השרת לא איטי בכלל לבקשות הרגילות של הקבצים שמגיעות אליו, בטח לא אחרי שכמעט כל הקבצים כבר מוגשים מהמטמון של קלאודפלייר.

המחשבה הראשונה היא שאולי זה קשור לחיבור של הSSE שבעצם נשאר מחובר באופן קבוע, ואולי נספר לחיבורים עד שמתמלאת המכסה, אבל בWebSockets הרי יש תמיכה עד כמה שידוע לי, וגם SSE אמור לכאו' להיכלל בתמיכה הזו.

כמו כן לא מצאתי שום אזכור ברשת על צורך בהחרגת SSE מהreverse proxy של קלאודפלייר.

כמה AI ששאלתי לא כל כך הצליחו להסביר לי למה זה קורה, ומיד אחרי שהעלתי את ההשערה לגבי הSSE הם קפצו על זה מיד והחליטו שצריך לפצל את הSSE לתת דומיין נפרד, אבל כמובן אינני יכול לסמוך עליהם בענין.

אם מישהו יודע האם באמת יש צורך לפצל את הSSE לדומיין נפרד עם ענן אפור, או שיודע מה יכול להיות הסבר אחר לשגיאה, אשמח אם יוכל לעזור לי.

@צדיק-תמים הציע לי במתמחים טופ להשתמש בcloudflare tunnel, ניסיתי גם את זה, ולא עזר.

החיבור מוגדר לhttp2 או 3 מקלאודפלייר לשרת.

בעיקרון גם ניסיתי כבר את לפצל את הדומיין של הSSE לנפרד, ועדיין היה שגיאה, אבל אני לא בטוח במאה אחוז שזה למרות זאת, כי ייתכן שזה ממשתמשים שנשארו עדיין מחוברים לדומיין הישן שלא חסמתי אותו.

[dovid]

אכן, לא נראה שעצם SSE אמור לסבול מבעיה בCF, אבל יכול להיות שספציפית במקרה שלך החיבור ביניהם בעייתי.
אם תרצה בכך, אולי יעזור שתסביר לנו רקע מה אתה משתמש ואיך בSSE, כלומר או קוד של צד השרת או תיאור של מה שהוא עושה.
מציין בדבריך שני נקודות (כנראה נובעות מאי שימת לב שהקוראים לא בפרטי העניין):
א. "המון פעמים שגיאה 1200 בכניסה"
מה הכונה כניסה?
ב. "השאלה למה זה קורה, השרת לא איטי בכלל לבקשות הרגילות של הקבצים שמגיעות אליו, בטח לא אחרי שכמעט כל הקבצים כבר מוגשים מהמטמון של קלאודפלייר."
מי דיבר על קבצים? מה פתאום מה שחוזר בSSE שזה בקשה אין סופית, יכול להיות מאוחזר ממטמון?

[ע"ה דכו"ע]

האתר הוא בעצם הפרוייקט של נטפרי - הערוץ https://github.com/NetFree-Community/TheChannel הSSE שם נועד כדי לשלוח מידע בזמן אמת למשתמש על הודעות חדשות ועל אימוג'ים שנוספו ע"י המשתמשים.

בעיקרון מאותו דומיין מוגשים גם הקבצים הסטטיים של הצד לקוח, גם התוכן של הערוץ שמוגש כjson בנתיב API, גם המדיה, וגם החיבור SSE (מה שניסיתי להפריד זה את הSSE לדומיין אחד וכל שאר התכנים נשארו בדומיין הראשי).

א. כניסה הכוונה כשנכנסים לאתר, או כשמרעננים את הדף של האתר.
ב. כמו שכתבתי ישנם גם קבצים שמוגשים באתר.

[קינג קומפיוטר]

אולי יש קשר בין הדברים?
https://tchumim.com/post/170422

[ע"ה דכו"ע]

@קינג-קומפיוטר כתב במה יכול להיות סיבה לשגיאה 1200 חוזרת ונשנית באתר שמוגש דרך קלאודפלייר?:

אולי יש קשר בין הדברים?
https://tchumim.com/post/170422

החיבור שלי לSSE כן פתוח בנטפרי, רק שאחרי כמה דקות מקבלים שגיאה 1200

[dovid]

@ע-ה-דכו-ע כתב במה יכול להיות סיבה לשגיאה 1200 חוזרת ונשנית באתר שמוגש דרך קלאודפלייר?:

האתר הוא בעצם הפרוייקט של נטפרי - הערוץ https://github.com/NetFree-Community/TheChannel הSSE שם נועד כדי לשלוח מידע בזמן אמת למשתמש על הודעות חדשות ועל אימוג'ים שנוספו ע"י המשתמשים.

תוכל לכוון אותי, איפה הקוד שמגיב לבקשת הSSE?

[ע"ה דכו"ע]

בקוד המקורי זה כאן

אני שיניתי קצת את הקוד הזה, אז אני מצרף את הקובץ המלא

package main

import (
	"context"
	"encoding/json"
	"net/http"
	"sync"
	"sync/atomic"
	"time"
)

var openSSEConnections = atomic.Int64{}
var peakSSEConnections = &PeakSSEConnections{}
var peakMu = sync.Mutex{}

type PeakSSEConnections struct {
	Value     int64     `json:"value" redis:"value"`
	Timestamp time.Time `json:"timestamp" redis:"timestamp"`
}
type Statistics struct {
	Data   []int64  `json:"date"`
	Labels []string `json:"labels"`
}

func init() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	p, _ := dbGetPeakSSEConnections(ctx)
	peakMu.Lock()
	defer peakMu.Unlock()
	peakSSEConnections = p
}

func statLogger() {
	var old int64
	for {
		new := openSSEConnections.Load()
		if old != new {
			dbSaveSSEStatistics(new)
			old = new
		}
		time.Sleep(5 * time.Minute)
	}
}

func increaseCounterSSE() {
	new := openSSEConnections.Add(1)

	peakMu.Lock()
	defer peakMu.Unlock()
	if new > peakSSEConnections.Value {
		peakSSEConnections.Value = new
		peakSSEConnections.Timestamp = time.Now()
		peak := *peakSSEConnections
		go dbSavePeakSSEConnections(&peak)
	}
}

func decreaseCounterSSE() {
	openSSEConnections.Add(-1)
}

func getStatistics(w http.ResponseWriter, r *http.Request) {
	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
	defer cancel()

	amount, err := dbGetUsersAmount(ctx)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}

	s, err := dbGetSSEStatistics(ctx, 1000)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}

	peakMu.Lock()
	defer peakMu.Unlock()

	response := struct {
		UsersAmount           int64               `json:"usersAmount"`
		ConnectedUsersAmount  int64               `json:"connectedUsersAmount"`
		PeakSSEConnections    *PeakSSEConnections `json:"peakSSEConnections"`
		ConnectionsStatistics Statistics          `json:"connectionsStatistics"`
	}{
		UsersAmount:           amount,
		ConnectedUsersAmount:  openSSEConnections.Load(),
		PeakSSEConnections:    peakSSEConnections,
		ConnectionsStatistics: *s,
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(response)
}

func resetStatistics(w http.ResponseWriter, r *http.Request) {
	peakMu.Lock()
	defer peakMu.Unlock()
	peakSSEConnections.Value = 0
	peakSSEConnections.Timestamp = time.Time{}
	p := *peakSSEConnections
	go dbSavePeakSSEConnections(&p)

	var response Response
	response.Success = true
	json.NewEncoder(w).Encode(response)
}