docs: Kitex v0.13.0 release (#1300)

Author: DMwangnima

content/en/blog/releases/Kitex/release-v0_13_0.md

@@ -0,0 +1,114 @@
+---
+title: "Kitex Release v0.13.0"
+linkTitle: "Release v0.13.0"
+projects: ["Kitex"]
+date: 2025-04-07
+description: >
+---
+
+> We recommend upgrading directly to Kitex version v0.13.1, as we have fixed a potential Goroutine leak issue of the gRPC Client in v0.13.0.
+
+## **Introduction to Key Changes**
+
+### **New Features**
+1. **New streaming interface StreamX supports gRPC, existing Kitex gRPC users can migrate**
+
+    v0.12.0 released the StreamX interface to optimise the streaming experience, and supported the custom streaming protocol TTHeader Streaming, but did not support gRPC. So existing users could not migrate.
+
+    This version supports gRPC for StreamX, users can migrate to StreamX, and the Server side can be compatible with two streaming protocols at the same time. So there is no need to worry about protocol compatibility after interface migration.
+
+    In particular, when adapting gRPC with StreamX, we found that there are still some inconvenient problems. In order to bring a better experience of using the interface, we have adjusted the StreamX interface for the second time, which will affect the users who have already been using StreamX. We apologise for that.
+
+    User documentation: [StreamX User Documentation](/docs/kitex/tutorials/basic-feature/streamx)
+
+2. **Prutal - Protobuf's non-generated code serialisation library**
+
+    [Prutal](https://github.com/cloudwego/prutal) is officially open source, on par with Thrift's [Frugal](https://github.com/cloudwego/frugal), and the new version of Kitex integrates Prutal by default.
+
+    Advantages:
+
+    - Minimized Code Product Size: Generating Only Structures, No Runtime Code
+
+    - Leveraging Reflection Optimization Similar to Frugal, Achieving Over 50% Speed Increase
+
+    - Generating Code Compatible with Existing Protobuf and Derivative Versions
+
+    User documentation: [Prutal](/docs/kitex/tutorials/code-gen/prutal)
+
+### **Feature/Experience Optimization**
+1. **TTHeader Streaming: Support interface-level Recv timeout control**
+    
+    In addition to the existing Client level, this release of TTHeader Streaming supports interface-level Recv timeout configuration, making configuration more flexible.
+
+    User documentation: [StreamX Timeout Control](/docs/kitex/tutorials/basic-feature/streamx/kitex+streamx+-+stream+timeout+control/)
+
+2. **Default Thrift transport protocol changed from Buffered to Framed** 
+
+    This change can leverage FastCodec for better performance.
+
+### **Others**
+1. **Code Product Simplification** 
+    
+  - Kitex Tool would not generate the repeated verification code for Set data structure and the ```DeepEqual``` function for each structure by default.
+
+    - If you only want to restore```DeepEqual```, add```-thrift gen_deep_equal=true```to the generation command.
+
+    - If you want to restore the repeated verification of Set, add```-thrift validate_set=true, -thrift gen_deep_equal=true```to the generation command.
+
+  - Kitex Tool would not generate the Apache Codec related code by default.
+
+    - If you want to restore it, add```-thrift no_default_serdes=false```to the generation command.
+
+2. **Go Supported Version Change** 
+    
+    Support version Go 1.19~1.24, the lowest supported version becomes Go 1.19.
+
+    if Go version is too low, there will be a prompt when compiling:```note: module requires Go 1.19```.
+
+## **Full Change**
+### Feature
+[[#1719](https://github.com/cloudwego/kitex/pull/1719)] feat: prutal for replacing protoc
+
+[[#1736](https://github.com/cloudwego/kitex/pull/1736)] feat(ttstream): support WithRecvTimeout stream call option
+
+[[#1702](https://github.com/cloudwego/kitex/pull/1702)] feat(gRPC): add grpc client conn dump to help debug the conn and stream status
+
+[[#1723](https://github.com/cloudwego/kitex/pull/1723)] feat(codec/thrift): use fastcodec/frugal if apache codec not available
+
+[[#1724](https://github.com/cloudwego/kitex/pull/1724)] feat: add tail option to support for delayed initialization of some client options
+
+### Optimize
+[[#1728](https://github.com/cloudwego/kitex/pull/1728)] optimize(apache): remove apache codec gen and set default protocol from buffered to framed
+
+[[#1732](https://github.com/cloudwego/kitex/pull/1732)] optimize(rpcinfo): purify the transport protocol of rpcinfo in a single rpc request
+
+[[#1711](https://github.com/cloudwego/kitex/pull/1711)] optimize(tool): disable set validate and deep equal code gen to simplify kitex_gen
+
+[[#1717](https://github.com/cloudwego/kitex/pull/1717)] optimize(gRPC): return more detailed error when received invalid http2 frame
+
+### Fix
+[[#1734](https://github.com/cloudwego/kitex/pull/1734)] fix(ttstream): adjust stream state transition and remove all SetFinalizer to avoid memory leak
+
+[[#1735](https://github.com/cloudwego/kitex/pull/1735)] fix(generic): support both relative and absolute check for idl includes parse to make it compatible with generation tool
+
+[[#1725](https://github.com/cloudwego/kitex/pull/1725)] fix: code gen import issue for streamx mode, stream call judgement bug and set ttheader streaming as default
+
+[[#1727](https://github.com/cloudwego/kitex/pull/1727)] fix(tool): fix tool UseStdLib remains unexcepted lib issue
+
+### Refactor
+[[#1658](https://github.com/cloudwego/kitex/pull/1658)] refactor: streamx api to adapt both grpc and ttheader streaming protocol and provide more user-friendly interface
+
+[[#1729](https://github.com/cloudwego/kitex/pull/1729)] refactor(tool): move pb tpl code to sep pkg
+
+### Chore
+[[#1743](https://github.com/cloudwego/kitex/pull/1743)] chore: update dependencies version
+
+[[#1740](https://github.com/cloudwego/kitex/pull/1740)] chore(generic): deprecate NewThriftContentProvider
+
+[[#1741](https://github.com/cloudwego/kitex/pull/1741)] chore(streamx): remove redundant streamx package
+
+[[#1738](https://github.com/cloudwego/kitex/pull/1738)] ci: fix typos & crate-ci/typos
+
+[[#1737](https://github.com/cloudwego/kitex/pull/1737)] chore: update dependency and change go support to 1.19-1.24
+
+[[#1720](https://github.com/cloudwego/kitex/pull/1720)] Revert "fix(ttstream): pingpong method refers to server interface defined in Kitex generation code when streamx is enabled and there are other streaming methods"

content/en/docs/kitex/Tutorials/basic-feature/streamx/Kitex+StreamX+-+Stream+Basic+Programming.md

@@ -14,10 +14,10 @@ Current support:
 
   - Transport protocol: TTHeader
   - IDL Definition Language and Serialization Protocol: Thrift
-- **gRPC Streaming** : ~~~~(planned implementation)
+- **gRPC Streaming**
 
-  - ~~Transport protocol: gRPC~~
-  - ~~IDL Definition Language and Serialization Protocol: Protobuf Encoding~~
+  - Transport protocol: gRPC
+  - IDL Definition Language and Serialization Protocol: Thrift / Protobuf
 
 The protocol selected here only affects code generated from IDL. Regardless of the protocol, the following usage is consistent.
 
@@ -44,38 +44,42 @@ service TestService {
 ```
 
 #### Generate code
+Please make sure that Kitex Tool has been upgraded to v0.13.0+:
+```
+go install github.com/cloudwego/kitex/tool/cmd/kitex@latest
+```
 
-To maintain compatibility with legacy stream-generated code, Command Line needs to add `the -streamx ` flag.
+To maintain compatibility with legacy stream-generated code, Command Line needs to add the `-streamx` flag.
 
 ```
-kitex -streamx -module <go module> -service P.S.M echo.thrift
+kitex -streamx -module <go module> -service service echo.thrift
 ```
 
-##### Initialization
+### Initialization
 
 #### Create Client
 
 ```go
 import ".../kitex_gen/echo/testservice"
-import "github.com/cloudwego/kitex/client/streamxclient"
+import "github.com/cloudwego/kitex/client"
 
 cli, err := testservice.NewClient(
     "a.b.c",
-    streamxclient.WithStreamRecvMiddleware(...),
-    streamxclient.WithStreamSendMiddleware(...),
+    client.WithStreamRecvMiddleware(...),
+    client.WithStreamSendMiddleware(...),
 )
 ```
 
 #### Create Server
 
 ```go
-import ".../kitex_gen/echo/streamserver"
-import "github.com/cloudwego/kitex/server/streamxserver"
+import ".../kitex_gen/echo/testservice"
+import "github.com/cloudwego/kitex/server"
 
-svr := streamserver.NewServer(
+svr := testservice.NewServer(
     new(serviceImpl),
-    streamxserver.WithStreamRecvMiddleware(...),
-    streamxserver.WithStreamSendMiddleware(...),
+    server.WithStreamRecvMiddleware(...),
+    server.WithStreamSendMiddleware(...),
 )
 ```
 
@@ -101,14 +105,14 @@ client.CloseAndRecv(res) === EOF ==>       server.Recv(EOF)
 
 #### Client Usage
 
-- [**Must**] : The client must call the CloseAndRecv () or (CloseSend + Recv) method to inform the server that there is no new data to send.
+- [**Must**] : The client must call the CloseAndRecv() or (CloseSend + Recv) method to inform the server that there is no new data to send.
 
 ```go
-ctx, cs, err := cli.ClientStream(ctx)
+stream, err := cli.EchoClient(ctx)
 for i := 0; i < 3; i++ {
-    err = cs.Send(ctx, req)
+    err = stream.Send(stream.Context(), req)
 }
-res, err = cs.CloseAndRecv(ctx)
+res, err = stream.CloseAndRecv(stream.Context())
 ```
 
 #### Server usage
@@ -117,14 +121,14 @@ res, err = cs.CloseAndRecv(ctx)
 
 ```go
 
-func (si *serviceImpl) ClientStream(
-    ctx context.Context, stream streamx.ClientStreamingServer[Request, Response]
-) (res *Response, err error) {
+func (si *serviceImpl) EchoClient(
+    ctx context.Context, stream echo.TestService_EchoClientServer
+) (err error) {
     for {
        req, err := stream.Recv(ctx)
        if err == io.EOF {
            res := new(Response)
-           return res, nil
+           return stream.SendAndClose(ctx, res)
        }
        if err != nil {
           return nil, err
@@ -153,12 +157,12 @@ client.Recv(EOF)   <== EOF ===   server handler return
 
 #### Client Usage
 
-- [**Must**] : The client must check the io. EOF error and end the loop
+- [**Must**] : The client must check the io.EOF error and end the loop
 
 ```go
-ctx, ss, err := cli.ServerStream(ctx, req)
+stream, err := cli.EchoServer(ctx, req)
 for {
-    res, err := ss.Recv(ctx)
+    res, err := stream.Recv(stream.Context())
     if errors.Is(err, io.EOF) {
        break
     }
@@ -168,7 +172,7 @@ for {
 #### Server usage
 
 ```go
-func (si *serviceImpl) ServerStream(ctx context.Context, req *Request, stream streamx.ServerStreamingServer[Response]) error {
+func (si *serviceImpl) EchoServer(ctx context.Context, req *echo.Request, stream echo.TestService_EchoServerServer) error {
     for i := 0; i < 3; i++ {
        err := stream.Send(ctx, resp)
        if err != nil {
@@ -204,23 +208,23 @@ client.Recv(EOF)   <== EOF ===   server handler return
 #### Client Usage
 
 - [**Must**] : client must call CloseSend after sending
-- [**Must**] : client must judge io. EOF and end the loop when Recv
+- [**Must**] : client must judge io.EOF and end the loop when Recv
 
 ```go
-ctx, bs, err := cli.BidiStream(ctx)
+stream, err := cli.EchoBidi(ctx)
 var wg sync.WaitGroup
 wg.Add(2)
 go func() {
     defer wg.Done()
     for i := 0; i < round; i++ {
-       err := bs.Send(ctx, req)
+       err := stream.Send(stream.Context(), req)
     }
-    err = bs.CloseSend(ctx)
+    err = stream.CloseSend(stream.Context())
 }()
 go func() {
     defer wg.Done()
     for {
-       res, err := bs.Recv(ctx)
+       res, err := stream.Recv(stream.Context())
        if errors.Is(err, io.EOF) {
           break
        }
@@ -234,7 +238,7 @@ wg.Wait()
 - [**Must**] : The server must determine io. EOF and end the loop when Recv
 
 ```go
-func (si *serviceImpl) BidiStream(ctx context.Context, stream streamx.BidiStreamingServer[Request, Response]) error {
+func (si *serviceImpl) EchoBidi(ctx context.Context, stream echo.TestService_EchoBidiServer) error {
     for {
        req, err := stream.Recv(ctx)
        if err == io.EOF {

content/en/docs/kitex/Tutorials/basic-feature/streamx/Kitex+StreamX+-+Stream+Error+Handling.md

@@ -19,14 +19,14 @@ Unlike  RPC, stream errors can occur at any time during stream processing. For e
 Server implementation:
 
 ```go
-func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *Request, stream streamx.ServerStreamingServer[Response]) error {
+func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *echo.Request, stream echo.TestService_ServerStreamWithErrServer) error {
     // 检查用户账户余额
     for isHasBalance (req.UserId) {
         stream.Send(ctx, res)
     }
     // 返回用户余额不足错误
     bizErr := kerrors.NewBizStatusErrorWithExtra(
-        10001, "insufficient user balance", map[string]string{"testKey": "testVal"}，
+        10001, "insufficient user balance", map[string]string{"testKey": "testVal"},
     )
     return bizErr
 }
@@ -35,11 +35,11 @@ func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *Reques
 Client implementation:
 
 ```go
-svrStream, err = streamClient.ServerStreamWithErr(ctx, req)
+stream, err = cli.ServerStreamWithErr(ctx, req)
 
 var err error
 for {
-    res, err = stream.Recv(ctx)
+    res, err = stream.Recv(stream.Context())
     if err != nil {
          break
     }
@@ -52,12 +52,12 @@ if ok {
 
 ### Other errors
 
-If the Error returned by the Server is a non-business exception, the framework will be uniformly encapsulated as `(* thrift.ApplicationException) `. At this time, only the error Message can be obtained.
+If the Error returned by the Server is a non-business exception, the framework will be uniformly encapsulated as `(*thrift.ApplicationException)`. At this time, only the error Message can be obtained.
 
 Server implementation:
 
 ```go
-func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *Request, stream streamx.ServerStreamingServer[Response]) error {
+func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *echo.Request, stream echo.TestService_ServerStreamWithErrServer) error {
     // ...
     return errors.New("test error")
 }
@@ -66,16 +66,16 @@ func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *Reques
 Client implementation:
 
 ```go
-svrStream, err = streamClient.ServerStreamWithErr(ctx, req)
-test.Assert(t, err == nil, err)
+stream, err = cli.ServerStreamWithErr(ctx, req)
 
 var err error
 for {
-    res, err = stream.Recv(ctx)
+    res, err = stream.Recv(stream.Context())
     if err != nil {
          break
     }
 }
+
 ex, ok := err.(*thrift.ApplicationException)
 if ok {
      println(ex.TypeID(), ex.Msg())