Community

CNCF Slack account

To discuss issues and questions, the community uses the CNCF Slack account. The CNCF Slack account is a platform where developers can connect and discuss various topics related to OpenTelemetry. You can sign up for the CNCF Slack account at http://slack.cncf.io/.

GitHub Discussions

You can also join the discussion on GitHub Discussions. GitHub Discussions is a platform where you can ask questions, share ideas, and collaborate with other users. You can find the GitHub Discussions for the opentelemetry-demo repository at discussions.

Slack

The community also uses Slack to discuss issues and questions. You can join the Slack group for the opentelemetry-demo repository at https://cloud-native.slack.com/archives/C03B4CWV4DA.

otel-community-demo

The community uses the otel-community-demo Slack channel for discussing issues and questions. You can join the channel at https://app.slack.com/client/T08PSQ7BQ/C03B4CWV4DA.

Example

// src/checkoutservice/checkout.go

package main

import (
    "context"
    "fmt"
    "github.com/open-telemetry/opentelemetry-demo/src/checkoutservice/common"
    "github.com/open-telemetry/opentelemetry-demo/src/checkoutservice/model"
    "github.com/open-telemetry/opentelemetry-demo/src/checkoutservice/payment"
    "github.com/open-telemetry/opentelemetry-demo/src/checkoutservice/shipping"
    "github.com/open-telemetry/opentelemetry-demo/src/checkoutservice/users"
    "log"
    "net/http"
    "os"
    "time"
)

// Checkout defines the Checkout service interface.
type Checkout interface {
    Checkout(ctx context.Context, userID string, items []model.Item, paymentMethod model.PaymentMethod) (*model.Order, error)
}

// checkoutService implements the Checkout service.
type checkoutService struct {
    userClient   users.Client
    paymentClient payment.Client
    shippingClient shipping.Client
}

// NewCheckoutService creates a new instance of the Checkout service.
func NewCheckoutService(userClient users.Client, paymentClient payment.Client, shippingClient shipping.Client) Checkout {
    return &checkoutService{
        userClient:   userClient,
        paymentClient: paymentClient,
        shippingClient: shippingClient,
    }
}

// Checkout processes a checkout request.
func (s *checkoutService) Checkout(ctx context.Context, userID string, items []model.Item, paymentMethod model.PaymentMethod) (*model.Order, error) {
    // Validate the user.
    user, err := s.userClient.GetUser(ctx, userID)
    if err != nil {
        return nil, err
    }

    // Validate the items.
    for _, item := range items {
        if err := item.Validate(); err != nil {
            return nil, err
        }
    }

    // Validate the payment method.
    if err := paymentMethod.Validate(); err != nil {
        return nil, err
    }

    // Generate a new order ID.
    orderID := common.GenerateOrderID()

    // Create a new order.
    order := &model.Order{
        ID:            orderID,
        UserID:         userID,
        Items:          items,
        PaymentMethod: paymentMethod,
        Status:         model.OrderStatusPending,
        CreatedAt:      time.Now(),
    }

    // Process the payment.
    if err := s.paymentClient.ProcessPayment(ctx, paymentMethod, order.TotalCost()); err != nil {
        return nil, err
    }

    // Create the shipment.
    if err := s.shippingClient.CreateShipment(ctx, user.Address, order); err != nil {
        return nil, err
    }

    // Update the order status to "Processed".
    order.Status = model.OrderStatusProcessed

    // Log the order creation.
    log.Printf("Order created: %s", orderID)

    // Return the order.
    return order, nil
}

func main() {
    // Create a new Checkout service.
    checkoutService := NewCheckoutService(
        users.NewClient(),
        payment.NewClient(),
        shipping.NewClient(),
    )

    // Create a new HTTP server.
    http.HandleFunc("/checkout", func(w http.ResponseWriter, r *http.Request) {
        // Parse the request body.
        var checkoutRequest model.CheckoutRequest
        if err := common.ParseJSONRequest(r, &checkoutRequest); err != nil {
            common.RespondWithError(w, http.StatusBadRequest, err)
            return
        }

        // Process the checkout request.
        order, err := checkoutService.Checkout(r.Context(), checkoutRequest.UserID, checkoutRequest.Items, checkoutRequest.PaymentMethod)
        if err != nil {
            common.RespondWithError(w, http.StatusInternalServerError, err)
            return
        }

        // Respond with the order information.
        common.RespondWithJSON(w, http.StatusOK, order)
    })

    // Start the HTTP server.
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    log.Printf("Server listening on port %s", port)
    if err := http.ListenAndServe(fmt.Sprintf(":%s", port), nil); err != nil {
        log.Fatal(err)
    }
}