Обновить .github/workflows/job_sync.yml

Signed-off-by: Василий Толстов <v.tolstov@unistack.org>

.github/workflows/job_sync.yml

@@ -25,7 +25,7 @@ jobs:
         dst_hash=$(git ls-remote ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} refs/heads/master | cut -f1)
         echo "src_hash=$src_hash"
         echo "dst_hash=$dst_hash"
-        if [ "$src_hash" != "$dst_hash" ]; then
+        if [ "$src_hash" != "$dst_hash" -a "$src_hash" != "" -a "$dst_hash" != "" ]; then
           echo "sync_needed=true" >> $GITHUB_OUTPUT
         else
           echo "sync_needed=false" >> $GITHUB_OUTPUT

README.md

@@ -1,5 +1,5 @@
 # HTTP Client
-![Coverage](https://img.shields.io/badge/Coverage-42.4%25-yellow)
+![Coverage](https://img.shields.io/badge/Coverage-42.7%25-yellow)
 
 This plugin is an HTTP client for [Micro](https://pkg.go.dev/go.unistack.org/micro/v4).
 It implements the [micro.Client](https://pkg.go.dev/go.unistack.org/micro/v4/client#Client) interface.

client.go

@@ -12,8 +12,12 @@ import (
 	"go.unistack.org/micro/v4/options"
 	"go.unistack.org/micro/v4/semconv"
 	"go.unistack.org/micro/v4/tracer"
+
+	"go.unistack.org/micro-client-http/v4/status"
 )
 
+var _ client.Client = (*Client)(nil)
+
 var DefaultContentType = "application/json"
 
 type Client struct {
@@ -91,25 +95,45 @@ func (c *Client) NewRequest(service, method string, req any, opts ...client.Requ
 func (c *Client) Call(ctx context.Context, req client.Request, rsp any, opts ...client.CallOption) error {
 	ts := time.Now()
 	c.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Inc()
+
 	var sp tracer.Span
 	ctx, sp = c.opts.Tracer.Start(ctx, req.Endpoint()+" rpc-client",
 		tracer.WithSpanKind(tracer.SpanKindClient),
 		tracer.WithSpanLabels("endpoint", req.Endpoint()),
 	)
+	defer sp.Finish()
+
 	err := c.funcCall(ctx, req, rsp, opts...)
+
 	c.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Dec()
 	te := time.Since(ts)
 	c.opts.Meter.Summary(semconv.ClientRequestLatencyMicroseconds, "endpoint", req.Endpoint()).Update(te.Seconds())
 	c.opts.Meter.Histogram(semconv.ClientRequestDurationSeconds, "endpoint", req.Endpoint()).Update(te.Seconds())
 
-	if me := errors.FromError(err); me == nil {
-		sp.Finish()
-		c.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "success", "code", strconv.Itoa(int(200))).Inc()
-	} else {
+	var (
+		statusCode  int
+		statusLabel string
+	)
+
+	if err == nil {
+		statusCode = http.StatusOK
+		statusLabel = "success"
+	} else if st, ok := status.FromError(err); ok {
+		statusCode = st.Code()
+		statusLabel = "failure"
+		sp.SetStatus(tracer.SpanStatusError, err.Error())
+	} else if me := errors.FromError(err); me != nil {
+		statusCode = int(me.Code)
+		statusLabel = "failure"
+		sp.SetStatus(tracer.SpanStatusError, err.Error())
+	} else {
+		statusCode = http.StatusInternalServerError
+		statusLabel = "failure"
 		sp.SetStatus(tracer.SpanStatusError, err.Error())
-		c.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "failure", "code", strconv.Itoa(int(me.Code))).Inc()
 	}
 
+	c.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", statusLabel, "code", strconv.Itoa(statusCode)).Inc()
+
 	return err
 }
 

client_helpers.go

@@ -119,10 +119,23 @@ func buildHTTPRequest(
 	}
 
 	if log.V(logger.DebugLevel) {
-		log.Debug(
-			ctx,
-			fmt.Sprintf("request %s to %s with headers %v body %s", method, u.String(), hreq.Header, body),
-		)
+		if shouldLogBody(ct) {
+			log.Debug(
+				ctx,
+				fmt.Sprintf(
+					"micro.client http request: method=%s url=%s headers=%v body=%s",
+					method, u.String(), hreq.Header, body,
+				),
+			)
+		} else {
+			log.Debug(
+				ctx,
+				fmt.Sprintf(
+					"micro.client http request: method=%s url=%s headers=%v",
+					method, u.String(), hreq.Header,
+				),
+			)
+		}
 	}
 
 	return hreq, nil
@@ -261,3 +274,18 @@ func validateHeadersAndCookies(r *http.Request, parameters map[string]map[string
 
 	return nil
 }
+
+func shouldLogBody(contentType string) bool {
+	ct := strings.ToLower(strings.Split(contentType, ";")[0])
+	switch {
+	case strings.HasPrefix(ct, "text/"): // => text/html, text/plain, text/csv etc.
+		return true
+	case ct == "application/json",
+		ct == "application/xml",
+		ct == "application/x-www-form-urlencoded",
+		ct == "application/yaml":
+		return true
+	default:
+		return false
+	}
+}

client_helpers_test.go

@@ -399,3 +399,49 @@ func TestValidateHeadersAndCookies(t *testing.T) {
 		})
 	}
 }
+
+func TestShouldLogBody(t *testing.T) {
+	tests := []struct {
+		name        string
+		contentType string
+		want        bool
+	}{
+		// --- text/*
+		{"plain text", "text/plain", true},
+		{"html", "text/html", true},
+		{"csv", "text/csv", true},
+		{"yaml text", "text/yaml", true},
+
+		// --- application/*
+		{"json", "application/json", true},
+		{"xml", "application/xml", true},
+		{"form-urlencoded", "application/x-www-form-urlencoded", true},
+		{"yaml", "application/yaml", true},
+
+		// --- with parameters
+		{"json with charset", "application/json; charset=utf-8", true},
+		{"binary with charset", "application/octet-stream; charset=utf-8", false},
+
+		// --- binary
+		{"multipart form", "multipart/form-data", false},
+		{"binary stream", "application/octet-stream", false},
+		{"pdf", "application/pdf", false},
+		{"protobuf", "application/protobuf", false},
+		{"image", "image/png", false},
+
+		// --- edge cases
+		{"upper case type", "APPLICATION/JSON", true},
+		{"mixed case type", "Text/HTML", true},
+		{"unknown text prefix", "TEXT/FOO", true},
+		{"weird semicolon only", ";", false},
+		{"spaces only", "   ", false},
+		{"empty content-type", "", false},
+		{"missing main type", "/plain", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equal(t, tt.want, shouldLogBody(tt.contentType))
+		})
+	}
+}

client_unary_call.go

@@ -207,8 +207,6 @@ func (c *Client) parseRsp(ctx context.Context, hrsp *http.Response, rsp any, opt
 	default:
 	}
 
-	var buf []byte
-
 	if opts.ResponseMetadata != nil {
 		for k, v := range hrsp.Header {
 			opts.ResponseMetadata.Append(k, v...)
@@ -224,6 +222,8 @@ func (c *Client) parseRsp(ctx context.Context, hrsp *http.Response, rsp any, opt
 		ct = htype
 	}
 
+	var buf []byte
+
 	if hrsp.Body != nil {
 		var err error
 		buf, err = io.ReadAll(hrsp.Body)
@@ -232,15 +232,31 @@ func (c *Client) parseRsp(ctx context.Context, hrsp *http.Response, rsp any, opt
 		}
 	}
 
+	if log.V(logger.DebugLevel) {
+		if shouldLogBody(ct) {
+			log.Debug(
+				ctx,
+				fmt.Sprintf(
+					"micro.client http response: status=%s headers=%v body=%s",
+					hrsp.Status, hrsp.Header, buf,
+				),
+			)
+		} else {
+			log.Debug(
+				ctx,
+				fmt.Sprintf(
+					"micro.client http response: status=%s headers=%v",
+					hrsp.Status, hrsp.Header,
+				),
+			)
+		}
+	}
+
 	cf, err := c.newCodec(ct)
 	if err != nil {
 		return errors.InternalServerError("go.micro.client", "unknown content-type %s: %v", ct, err)
 	}
 
-	if log.V(logger.DebugLevel) {
-		log.Debug(ctx, fmt.Sprintf("response with headers: %v and body: %s", hrsp.Header, buf))
-	}
-
 	if hrsp.StatusCode < http.StatusBadRequest {
 		if err = cf.Unmarshal(buf, rsp); err != nil {
 			return errors.InternalServerError("go.micro.client", "unmarshal response: %v", err)