Publish Cloud-OpsBench v1.0.0 benchmark artifacts (part 29)

Source: https://github.com/LLM4Ops/Cloud-OpsBench/tree/ea05dafbc87b5985df8721622d63d4229c2b4224

benchmark/boutique/scheduling/11/metadata.json

@@ -0,0 +1,10 @@
+{
+  "namespace": "boutique",
+  "query": "Partial Service Unreachability.",
+  "difficulty": "easy",
+  "result": {
+    "fault_taxonomy": "Scheduling_Fault",
+    "fault_object": "app/currencyservice",
+    "root_cause": "node_cordon_mismatch"
+  }
+}

benchmark/boutique/scheduling/11/raw_data/alert.json

@@ -0,0 +1 @@
+{}

benchmark/boutique/scheduling/110/code/adservice/src/main/java/hipstershop/AdService.java

@@ -0,0 +1,238 @@
+/*
+ * Copyright 2018, Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package hipstershop;
+
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import hipstershop.Demo.Ad;
+import hipstershop.Demo.AdRequest;
+import hipstershop.Demo.AdResponse;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.services.*;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public final class AdService {
+
+  private static final Logger logger = LogManager.getLogger(AdService.class);
+
+  @SuppressWarnings("FieldCanBeLocal")
+  private static int MAX_ADS_TO_SERVE = 2;
+
+  private Server server;
+  private HealthStatusManager healthMgr;
+
+  private static final AdService service = new AdService();
+
+  private void start() throws IOException {
+    int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "9555"));
+    healthMgr = new HealthStatusManager();
+
+    server =
+        ServerBuilder.forPort(port)
+            .addService(new AdServiceImpl())
+            .addService(healthMgr.getHealthService())
+            .build()
+            .start();
+    logger.info("Ad Service started, listening on " + port);
+    Runtime.getRuntime()
+        .addShutdownHook(
+            new Thread(
+                () -> {
+                  // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+                  System.err.println(
+                      "*** shutting down gRPC ads server since JVM is shutting down");
+                  AdService.this.stop();
+                  System.err.println("*** server shut down");
+                }));
+    healthMgr.setStatus("", ServingStatus.SERVING);
+  }
+
+  private void stop() {
+    if (server != null) {
+      healthMgr.clearStatus("");
+      server.shutdown();
+    }
+  }
+
+  private static class AdServiceImpl extends hipstershop.AdServiceGrpc.AdServiceImplBase {
+
+    /**
+     * Retrieves ads based on context provided in the request {@code AdRequest}.
+     *
+     * @param req the request containing context.
+     * @param responseObserver the stream observer which gets notified with the value of {@code
+     *     AdResponse}
+     */
+    @Override
+    public void getAds(AdRequest req, StreamObserver<AdResponse> responseObserver) {
+      AdService service = AdService.getInstance();
+      try {
+        List<Ad> allAds = new ArrayList<>();
+        logger.info("received ad request (context_words=" + req.getContextKeysList() + ")");
+        if (req.getContextKeysCount() > 0) {
+          for (int i = 0; i < req.getContextKeysCount(); i++) {
+            Collection<Ad> ads = service.getAdsByCategory(req.getContextKeys(i));
+            allAds.addAll(ads);
+          }
+        } else {
+          allAds = service.getRandomAds();
+        }
+        if (allAds.isEmpty()) {
+          // Serve random ads.
+          allAds = service.getRandomAds();
+        }
+        AdResponse reply = AdResponse.newBuilder().addAllAds(allAds).build();
+        responseObserver.onNext(reply);
+        responseObserver.onCompleted();
+      } catch (StatusRuntimeException e) {
+        logger.log(Level.WARN, "GetAds Failed with status {}", e.getStatus());
+        responseObserver.onError(e);
+      }
+    }
+  }
+
+  private static final ImmutableListMultimap<String, Ad> adsMap = createAdsMap();
+
+  private Collection<Ad> getAdsByCategory(String category) {
+    return adsMap.get(category);
+  }
+
+  private static final Random random = new Random();
+
+  private List<Ad> getRandomAds() {
+    List<Ad> ads = new ArrayList<>(MAX_ADS_TO_SERVE);
+    Collection<Ad> allAds = adsMap.values();
+    for (int i = 0; i < MAX_ADS_TO_SERVE; i++) {
+      ads.add(Iterables.get(allAds, random.nextInt(allAds.size())));
+    }
+    return ads;
+  }
+
+  private static AdService getInstance() {
+    return service;
+  }
+
+  /** Await termination on the main thread since the grpc library uses daemon threads. */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  private static ImmutableListMultimap<String, Ad> createAdsMap() {
+    Ad hairdryer =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/2ZYFJ3GM2N")
+            .setText("Hairdryer for sale. 50% off.")
+            .build();
+    Ad tankTop =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/66VCHSJNUP")
+            .setText("Tank top for sale. 20% off.")
+            .build();
+    Ad candleHolder =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/0PUK6V6EV0")
+            .setText("Candle holder for sale. 30% off.")
+            .build();
+    Ad bambooGlassJar =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/9SIQT8TOJO")
+            .setText("Bamboo glass jar for sale. 10% off.")
+            .build();
+    Ad watch =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/1YMWWN1N4O")
+            .setText("Watch for sale. Buy one, get second kit for free")
+            .build();
+    Ad mug =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/6E92ZMYYFZ")
+            .setText("Mug for sale. Buy two, get third one for free")
+            .build();
+    Ad loafers =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/L9ECAV7KIM")
+            .setText("Loafers for sale. Buy one, get second one for free")
+            .build();
+    return ImmutableListMultimap.<String, Ad>builder()
+        .putAll("clothing", tankTop)
+        .putAll("accessories", watch)
+        .putAll("footwear", loafers)
+        .putAll("hair", hairdryer)
+        .putAll("decor", candleHolder)
+        .putAll("kitchen", bambooGlassJar, mug)
+        .build();
+  }
+
+  private static void initStats() {
+    if (System.getenv("DISABLE_STATS") != null) {
+      logger.info("Stats disabled.");
+      return;
+    }
+    logger.info("Stats enabled, but temporarily unavailable");
+
+    long sleepTime = 10; /* seconds */
+    int maxAttempts = 5;
+
+    // TODO(arbrown) Implement OpenTelemetry stats
+
+  }
+
+  private static void initTracing() {
+    if (System.getenv("DISABLE_TRACING") != null) {
+      logger.info("Tracing disabled.");
+      return;
+    }
+    logger.info("Tracing enabled but temporarily unavailable");
+    logger.info("See https://github.com/GoogleCloudPlatform/microservices-demo/issues/422 for more info.");
+
+    // TODO(arbrown) Implement OpenTelemetry tracing
+    
+    logger.info("Tracing enabled - Stackdriver exporter initialized.");
+  }
+
+  /** Main launches the server from the command line. */
+  public static void main(String[] args) throws IOException, InterruptedException {
+
+    new Thread(
+            () -> {
+              initStats();
+              initTracing();
+            })
+        .start();
+
+    // Start the RPC server. You shouldn't see any output from gRPC before this.
+    logger.info("AdService starting.");
+    final AdService service = AdService.getInstance();
+    service.start();
+    service.blockUntilShutdown();
+  }
+}

benchmark/boutique/scheduling/110/code/adservice/src/main/java/hipstershop/AdServiceClient.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2018, Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package hipstershop;
+
+import hipstershop.Demo.Ad;
+import hipstershop.Demo.AdRequest;
+import hipstershop.Demo.AdResponse;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/** A simple client that requests ads from the Ads Service. */
+public class AdServiceClient {
+
+  private static final Logger logger = LogManager.getLogger(AdServiceClient.class);
+
+  private final ManagedChannel channel;
+  private final hipstershop.AdServiceGrpc.AdServiceBlockingStub blockingStub;
+
+  /** Construct client connecting to Ad Service at {@code host:port}. */
+  private AdServiceClient(String host, int port) {
+    this(
+        ManagedChannelBuilder.forAddress(host, port)
+            // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
+            // needing certificates.
+            .usePlaintext()
+            .build());
+  }
+
+  /** Construct client for accessing RouteGuide server using the existing channel. */
+  private AdServiceClient(ManagedChannel channel) {
+    this.channel = channel;
+    blockingStub = hipstershop.AdServiceGrpc.newBlockingStub(channel);
+  }
+
+  private void shutdown() throws InterruptedException {
+    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+  }
+
+  /** Get Ads from Server. */
+  public void getAds(String contextKey) {
+    logger.info("Get Ads with context " + contextKey + " ...");
+    AdRequest request = AdRequest.newBuilder().addContextKeys(contextKey).build();
+    AdResponse response;
+
+    try {
+      response = blockingStub.getAds(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARN, "RPC failed: " + e.getStatus());
+      return;
+    } 
+    for (Ad ads : response.getAdsList()) {
+      logger.info("Ads: " + ads.getText());
+    }
+  }
+
+  private static int getPortOrDefaultFromArgs(String[] args) {
+    int portNumber = 9555;
+    if (2 < args.length) {
+      try {
+        portNumber = Integer.parseInt(args[2]);
+      } catch (NumberFormatException e) {
+        logger.warn(String.format("Port %s is invalid, use default port %d.", args[2], 9555));
+      }
+    }
+    return portNumber;
+  }
+
+  private static String getStringOrDefaultFromArgs(
+      String[] args, int index, @Nullable String defaultString) {
+    String s = defaultString;
+    if (index < args.length) {
+      s = args[index];
+    }
+    return s;
+  }
+
+  /**
+   * Ads Service Client main. If provided, the first element of {@code args} is the context key to
+   * get the ads from the Ads Service
+   */
+  public static void main(String[] args) throws InterruptedException {
+    // Add final keyword to pass checkStyle.
+    final String contextKeys = getStringOrDefaultFromArgs(args, 0, "camera");
+    final String host = getStringOrDefaultFromArgs(args, 1, "localhost");
+    final int serverPort = getPortOrDefaultFromArgs(args);
+
+    AdServiceClient client = new AdServiceClient(host, serverPort);
+    try {
+      client.getAds(contextKeys);
+    } finally {
+      client.shutdown();
+    }
+
+    logger.info("Exiting AdServiceClient...");
+  }
+}

benchmark/boutique/scheduling/110/code/cartservice/src/Program.cs

@@ -0,0 +1,26 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Hosting;
+using cartservice;
+
+CreateHostBuilder(args).Build().Run();
+
+static IHostBuilder CreateHostBuilder(string[] args) =>
+    Host.CreateDefaultBuilder(args)
+        .ConfigureWebHostDefaults(webBuilder =>
+        {
+            webBuilder.UseStartup<Startup>();
+        });

benchmark/boutique/scheduling/110/code/cartservice/src/Startup.cs

@@ -0,0 +1,84 @@
+using System;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Diagnostics.HealthChecks;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Microsoft.Extensions.Hosting;
+using cartservice.cartstore;
+using cartservice.services;
+using Microsoft.Extensions.Caching.StackExchangeRedis;
+
+namespace cartservice
+{
+    public class Startup
+    {
+        public Startup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration { get; }
+        
+        // This method gets called by the runtime. Use this method to add services to the container.
+        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
+        public void ConfigureServices(IServiceCollection services)
+        {
+            string redisAddress = Configuration["REDIS_ADDR"];
+            string spannerProjectId = Configuration["SPANNER_PROJECT"];
+            string spannerConnectionString = Configuration["SPANNER_CONNECTION_STRING"];
+            string alloyDBConnectionString = Configuration["ALLOYDB_PRIMARY_IP"];
+
+            if (!string.IsNullOrEmpty(redisAddress))
+            {
+                services.AddStackExchangeRedisCache(options =>
+                {
+                    options.Configuration = redisAddress;
+                });
+                services.AddSingleton<ICartStore, RedisCartStore>();
+            }
+            else if (!string.IsNullOrEmpty(spannerProjectId) || !string.IsNullOrEmpty(spannerConnectionString))
+            {
+                services.AddSingleton<ICartStore, SpannerCartStore>();
+            }
+            else if (!string.IsNullOrEmpty(alloyDBConnectionString))
+            {
+                Console.WriteLine("Creating AlloyDB cart store");
+                services.AddSingleton<ICartStore, AlloyDBCartStore>();
+            }
+            else
+            {
+                Console.WriteLine("Redis cache host(hostname+port) was not specified. Starting a cart service using in memory store");
+                services.AddDistributedMemoryCache();
+                services.AddSingleton<ICartStore, RedisCartStore>();
+            }
+
+
+            services.AddGrpc();
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+
+            app.UseRouting();
+
+            app.UseEndpoints(endpoints =>
+            {
+                endpoints.MapGrpcService<CartService>();
+                endpoints.MapGrpcService<cartservice.services.HealthCheckService>();
+
+                endpoints.MapGet("/", async context =>
+                {
+                    await context.Response.WriteAsync("Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
+                });
+            });
+        }
+    }
+}

benchmark/boutique/scheduling/110/code/cartservice/src/cartstore/AlloyDBCartStore.cs

@@ -0,0 +1,177 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using Grpc.Core;
+using Npgsql;
+using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Google.Api.Gax.ResourceNames;
+using Google.Cloud.SecretManager.V1;
+ 
+namespace cartservice.cartstore
+{
+    public class AlloyDBCartStore : ICartStore
+    {
+        private readonly string tableName;
+        private readonly string connectionString;
+
+        public AlloyDBCartStore(IConfiguration configuration)
+        {
+            // Create a Cloud Secrets client.
+            SecretManagerServiceClient client = SecretManagerServiceClient.Create();
+            var projectId = configuration["PROJECT_ID"];
+            var secretId = configuration["ALLOYDB_SECRET_NAME"];
+            SecretVersionName secretVersionName = new SecretVersionName(projectId, secretId, "latest");
+
+            AccessSecretVersionResponse result = client.AccessSecretVersion(secretVersionName);
+            // Convert the payload to a string. Payloads are bytes by default.
+            string alloyDBPassword = result.Payload.Data.ToStringUtf8().TrimEnd('\r', '\n');
+        
+            // TODO: Create a separate user for connecting within the application
+            // rather than using our superuser
+            string alloyDBUser = "postgres";
+            string databaseName = configuration["ALLOYDB_DATABASE_NAME"];
+            // TODO: Consider splitting workloads into read vs. write and take
+            // advantage of the AlloyDB read pools
+            string primaryIPAddress = configuration["ALLOYDB_PRIMARY_IP"];
+            connectionString = "Host="          +
+                               primaryIPAddress +
+                               ";Username="     +
+                               alloyDBUser      +
+                               ";Password="     +
+                               alloyDBPassword  +
+                               ";Database="     +
+                               databaseName;
+
+            tableName = configuration["ALLOYDB_TABLE_NAME"];
+        }
+
+
+    public async Task AddItemAsync(string userId, string productId, int quantity)
+    {
+        Console.WriteLine($"AddItemAsync for {userId} called");
+        try
+        {
+            await using var dataSource = NpgsqlDataSource.Create(connectionString);
+
+            var fetchCmd = $"SELECT quantity FROM {tableName} WHERE userID='{userId}' AND productID='{productId}'";
+            var currentQuantity = 0;
+            var cmdRead = dataSource.CreateCommand(fetchCmd);
+            await using (var reader = await cmdRead.ExecuteReaderAsync())
+            {
+                while (await reader.ReadAsync())
+                    currentQuantity += reader.GetInt32(0);
+            }
+
+            var totalQuantity = quantity + currentQuantity;
+
+            // Use INSERT ... ON CONFLICT to prevent duplicate key error
+            var insertCmd = $@"
+                INSERT INTO {tableName} (userId, productId, quantity)
+                VALUES ('{userId}', '{productId}', {totalQuantity})
+                ON CONFLICT (userId, productId)
+                DO UPDATE SET quantity = {totalQuantity};
+            ";
+
+            await using (var cmdInsert = dataSource.CreateCommand(insertCmd))
+            {
+                await Task.Run(() =>
+                {
+                    return cmdInsert.ExecuteNonQueryAsync();
+                });
+            }
+        }
+        catch (Exception ex)
+        {   
+            throw new RpcException(
+                new Status(StatusCode.FailedPrecondition, $"Unable to access cart storage due to an internal error. {ex}"));
+        }
+    }
+
+
+        public async Task<Hipstershop.Cart> GetCartAsync(string userId)
+        {
+            Console.WriteLine($"GetCartAsync called for userId={userId}");
+            Hipstershop.Cart cart = new();
+            cart.UserId = userId;
+            try
+            {
+                await using var dataSource = NpgsqlDataSource.Create(connectionString);
+
+                var cartFetchCmd = $"SELECT productId, quantity FROM {tableName} WHERE userId = '{userId}'";
+                var cmd = dataSource.CreateCommand(cartFetchCmd);
+                await using (var reader = await cmd.ExecuteReaderAsync())
+                {
+                    while (await reader.ReadAsync())
+                    {
+                        Hipstershop.CartItem item = new()
+                        {
+                            ProductId = reader.GetString(0),
+                            Quantity = reader.GetInt32(1)
+                        };
+                        cart.Items.Add(item);
+                    }
+                }
+                await Task.Run(() =>
+                {
+                    return cart;
+                });
+            }
+            catch (Exception ex)
+            {
+                throw new RpcException(
+                    new Status(StatusCode.FailedPrecondition, $"Unable to access cart storage due to an internal error. {ex}"));
+            }
+            return cart;
+        }
+
+
+        public async Task EmptyCartAsync(string userId)
+        {
+            Console.WriteLine($"EmptyCartAsync called for userId={userId}");
+
+            try
+            {
+                await using var dataSource = NpgsqlDataSource.Create(connectionString);
+                var deleteCmd = $"DELETE FROM {tableName} WHERE userID = '{userId}'";
+                await using (var cmd = dataSource.CreateCommand(deleteCmd))
+                {
+                    await Task.Run(() =>
+                    {
+                        return cmd.ExecuteNonQueryAsync();
+                    });
+                }
+            }
+            catch (Exception ex)
+            {
+                throw new RpcException(
+                    new Status(StatusCode.FailedPrecondition, $"Unable to access cart storage due to an internal error. {ex}"));
+            }
+        }
+
+        public bool Ping()
+        {
+            try
+            {
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+    }
+}
+

benchmark/boutique/scheduling/110/code/cartservice/src/cartstore/ICartStore.cs

@@ -0,0 +1,26 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Threading.Tasks;
+
+namespace cartservice.cartstore
+{
+    public interface ICartStore
+    {
+        Task AddItemAsync(string userId, string productId, int quantity);
+        Task EmptyCartAsync(string userId);
+        Task<Hipstershop.Cart> GetCartAsync(string userId);
+        bool Ping();
+    }
+}

benchmark/boutique/scheduling/110/code/cartservice/src/cartstore/RedisCartStore.cs

@@ -0,0 +1,118 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Grpc.Core;
+using Microsoft.Extensions.Caching.Distributed;
+using Google.Protobuf;
+
+namespace cartservice.cartstore
+{
+    public class RedisCartStore : ICartStore
+    {
+        private readonly IDistributedCache _cache;
+
+        public RedisCartStore(IDistributedCache cache)
+        {
+            _cache = cache;
+        }
+
+        public async Task AddItemAsync(string userId, string productId, int quantity)
+        {
+            Console.WriteLine($"AddItemAsync called with userId={userId}, productId={productId}, quantity={quantity}");
+
+            try
+            {
+                Hipstershop.Cart cart;
+                var value = await _cache.GetAsync(userId);
+                if (value == null)
+                {
+                    cart = new Hipstershop.Cart();
+                    cart.UserId = userId;
+                    cart.Items.Add(new Hipstershop.CartItem { ProductId = productId, Quantity = quantity });
+                }
+                else
+                {
+                    cart = Hipstershop.Cart.Parser.ParseFrom(value);
+                    var existingItem = cart.Items.SingleOrDefault(i => i.ProductId == productId);
+                    if (existingItem == null)
+                    {
+                        cart.Items.Add(new Hipstershop.CartItem { ProductId = productId, Quantity = quantity });
+                    }
+                    else
+                    {
+                        existingItem.Quantity += quantity;
+                    }
+                }
+                await _cache.SetAsync(userId, cart.ToByteArray());
+            }
+            catch (Exception ex)
+            {
+                throw new RpcException(new Status(StatusCode.FailedPrecondition, $"Can't access cart storage. {ex}"));
+            }
+        }
+
+        public async Task EmptyCartAsync(string userId)
+        {
+            Console.WriteLine($"EmptyCartAsync called with userId={userId}");
+
+            try
+            {
+                var cart = new Hipstershop.Cart();
+                await _cache.SetAsync(userId, cart.ToByteArray());
+            }
+            catch (Exception ex)
+            {
+                throw new RpcException(new Status(StatusCode.FailedPrecondition, $"Can't access cart storage. {ex}"));
+            }
+        }
+
+        public async Task<Hipstershop.Cart> GetCartAsync(string userId)
+        {
+            Console.WriteLine($"GetCartAsync called with userId={userId}");
+
+            try
+            {
+                // Access the cart from the cache
+                var value = await _cache.GetAsync(userId);
+
+                if (value != null)
+                {
+                    return Hipstershop.Cart.Parser.ParseFrom(value);
+                }
+
+                // We decided to return empty cart in cases when user wasn't in the cache before
+                return new Hipstershop.Cart();
+            }
+            catch (Exception ex)
+            {
+                throw new RpcException(new Status(StatusCode.FailedPrecondition, $"Can't access cart storage. {ex}"));
+            }
+        }
+
+        public bool Ping()
+        {
+            try
+            {
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+    }
+}

benchmark/boutique/scheduling/110/code/cartservice/src/cartstore/SpannerCartStore.cs

@@ -0,0 +1,185 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using Google.Cloud.Spanner.Data;
+using Grpc.Core;
+using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+
+namespace cartservice.cartstore
+{
+    public class SpannerCartStore : ICartStore
+    {
+        private static readonly string TableName = "CartItems";
+        private static readonly string DefaultInstanceName = "onlineboutique";
+        private static readonly string DefaultDatabaseName = "carts";
+        private readonly string databaseString;
+
+        public SpannerCartStore(IConfiguration configuration)
+        {
+            string spannerProjectId = configuration["SPANNER_PROJECT"];
+            string spannerInstanceId = configuration["SPANNER_INSTANCE"];
+            string spannerDatabaseId = configuration["SPANNER_DATABASE"];
+            string spannerConnectionString = configuration["SPANNER_CONNECTION_STRING"];
+            SpannerConnectionStringBuilder builder = new();
+            if (!string.IsNullOrEmpty(spannerConnectionString)) {
+                builder.DataSource = spannerConnectionString;
+                databaseString = builder.ToString();
+                Console.WriteLine($"Spanner connection string: ${databaseString}");
+                return;
+            }
+            if (string.IsNullOrEmpty(spannerInstanceId))
+                spannerInstanceId = DefaultInstanceName;
+            if (string.IsNullOrEmpty(spannerDatabaseId))
+                spannerDatabaseId = DefaultDatabaseName;
+            builder.DataSource =
+                $"projects/{spannerProjectId}/instances/{spannerInstanceId}/databases/{spannerDatabaseId}";
+            databaseString = builder.ToString();
+            Console.WriteLine($"Built Spanner connection string: '{databaseString}'");
+        }
+
+
+        public async Task AddItemAsync(string userId, string productId, int quantity)
+        {
+            Console.WriteLine($"AddItemAsync for {userId} called");
+            try
+            {
+                using SpannerConnection spannerConnection = new(databaseString);
+                await spannerConnection.RunWithRetriableTransactionAsync(async transaction =>
+                {
+                    int currentQuantity = 0;
+                    var quantityLookup = spannerConnection.CreateSelectCommand(
+                        $"SELECT * FROM {TableName} WHERE userId = @userId AND productId = @productId",
+                        new SpannerParameterCollection
+                        {
+                            { "userId", SpannerDbType.String },
+                            { "productId", SpannerDbType.String }
+                        });
+                    quantityLookup.Parameters["userId"].Value = userId;
+                    quantityLookup.Parameters["productId"].Value = productId;
+                    quantityLookup.Transaction = transaction;
+                    using (var reader = await quantityLookup.ExecuteReaderAsync())
+                    {
+                        while (await reader.ReadAsync()) {
+                            currentQuantity += reader.GetFieldValue<int>("quantity");
+                        }
+                    }
+
+                    var cmd = spannerConnection.CreateInsertOrUpdateCommand(TableName,
+                        new SpannerParameterCollection
+                        {
+                            { "userId", SpannerDbType.String },
+                            { "productId", SpannerDbType.String },
+                            { "quantity", SpannerDbType.Int64 }
+                        });
+                    cmd.Parameters["userId"].Value = userId;
+                    cmd.Parameters["productId"].Value = productId;
+                    cmd.Parameters["quantity"].Value = currentQuantity + quantity;
+                    cmd.Transaction = transaction;
+                    await Task.Run(() =>
+                    {
+                        return cmd.ExecuteNonQueryAsync();
+                    });
+                });
+            }
+            catch (Exception ex)
+            {
+                throw new RpcException(
+                    new Status(StatusCode.FailedPrecondition, $"Can't access cart storage at {databaseString}. {ex}"));
+            }
+        }
+
+
+        public async Task<Hipstershop.Cart> GetCartAsync(string userId)
+        {
+            Console.WriteLine($"GetCartAsync called for userId={userId}");
+            Hipstershop.Cart cart = new();
+            try
+            {
+                using SpannerConnection spannerConnection = new(databaseString);
+                var cmd = spannerConnection.CreateSelectCommand(
+                    $"SELECT * FROM {TableName} WHERE userId = @userId",
+                    new SpannerParameterCollection {
+                        { "userId", SpannerDbType.String }
+                    }
+                );
+                cmd.Parameters["userId"].Value = userId;
+                using var reader = await cmd.ExecuteReaderAsync();
+                while (await reader.ReadAsync())
+                {
+                    // Only add the userId if something is in the cart.
+                    // This is based on how the cartservice example behaves.
+                    // An empty cart has no userId attached.
+                    cart.UserId = userId;
+
+                    Hipstershop.CartItem item = new()
+                    {
+                        ProductId = reader.GetFieldValue<string>("productId"),
+                        Quantity = reader.GetFieldValue<int>("quantity")
+                    };
+                    cart.Items.Add(item);
+                }
+
+                return cart;
+            }
+            catch (Exception ex)
+            {
+                throw new RpcException(
+                    new Status(StatusCode.FailedPrecondition, $"Can't access cart storage at {databaseString}. {ex}"));
+            }
+        }
+
+
+        public async Task EmptyCartAsync(string userId)
+        {
+            Console.WriteLine($"EmptyCartAsync called for userId={userId}");
+
+            try
+            {
+                using SpannerConnection spannerConnection = new(databaseString);
+                await Task.Run(() =>
+                {
+                    var cmd = spannerConnection.CreateDmlCommand(
+                        $"DELETE FROM {TableName} WHERE userId = @userId",
+                    new SpannerParameterCollection
+                    {
+                        { "userId", SpannerDbType.String }
+                    });
+                    cmd.Parameters["userId"].Value = userId;
+                    return cmd.ExecuteNonQueryAsync();
+                });
+            }
+
+            catch (Exception ex)
+            {
+                throw new RpcException(
+                    new Status(StatusCode.FailedPrecondition, $"Can't access cart storage at {databaseString}. {ex}"));
+            }
+        }
+
+        public bool Ping()
+        {
+            try
+            {
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+    }
+}
+

benchmark/boutique/scheduling/110/code/cartservice/src/services/CartService.cs

@@ -0,0 +1,51 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Threading.Tasks;
+using Grpc.Core;
+using Microsoft.Extensions.Logging;
+using cartservice.cartstore;
+using Hipstershop;
+
+namespace cartservice.services
+{
+    public class CartService : Hipstershop.CartService.CartServiceBase
+    {
+        private readonly static Empty Empty = new Empty();
+        private readonly ICartStore _cartStore;
+
+        public CartService(ICartStore cartStore)
+        {
+            _cartStore = cartStore;
+        }
+
+        public async override Task<Empty> AddItem(AddItemRequest request, ServerCallContext context)
+        {
+            await _cartStore.AddItemAsync(request.UserId, request.Item.ProductId, request.Item.Quantity);
+            return Empty;
+        }
+
+        public override Task<Cart> GetCart(GetCartRequest request, ServerCallContext context)
+        {
+            return _cartStore.GetCartAsync(request.UserId);
+        }
+
+        public async override Task<Empty> EmptyCart(EmptyCartRequest request, ServerCallContext context)
+        {
+            await _cartStore.EmptyCartAsync(request.UserId);
+            return Empty;
+        }
+    }
+}

benchmark/boutique/scheduling/110/code/cartservice/src/services/HealthCheckService.cs

@@ -0,0 +1,41 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Threading.Tasks;
+using Grpc.Core;
+using Grpc.Health.V1;
+using static Grpc.Health.V1.Health;
+using cartservice.cartstore;
+
+namespace cartservice.services
+{
+    internal class HealthCheckService : HealthBase
+    {
+        private ICartStore _cartStore { get; }
+
+        public HealthCheckService (ICartStore cartStore) 
+        {
+            _cartStore = cartStore;
+        }
+
+        public override Task<HealthCheckResponse> Check(HealthCheckRequest request, ServerCallContext context)
+        {
+            Console.WriteLine ("Checking CartService Health");
+            return Task.FromResult(new HealthCheckResponse {
+                Status = _cartStore.Ping() ? HealthCheckResponse.Types.ServingStatus.Serving : HealthCheckResponse.Types.ServingStatus.NotServing
+            });
+        }
+    }
+}

benchmark/boutique/scheduling/110/code/checkoutservice/main.go

@@ -0,0 +1,394 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"os"
+	"time"
+
+	"cloud.google.com/go/profiler"
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/health"
+	"google.golang.org/grpc/status"
+
+	pb "github.com/GoogleCloudPlatform/microservices-demo/src/checkoutservice/genproto"
+	money "github.com/GoogleCloudPlatform/microservices-demo/src/checkoutservice/money"
+	healthpb "google.golang.org/grpc/health/grpc_health_v1"
+
+	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/propagation"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+)
+
+const (
+	listenPort  = "5050"
+	usdCurrency = "USD"
+)
+
+var log *logrus.Logger
+
+func init() {
+	log = logrus.New()
+	log.Level = logrus.DebugLevel
+	log.Formatter = &logrus.JSONFormatter{
+		FieldMap: logrus.FieldMap{
+			logrus.FieldKeyTime:  "timestamp",
+			logrus.FieldKeyLevel: "severity",
+			logrus.FieldKeyMsg:   "message",
+		},
+		TimestampFormat: time.RFC3339Nano,
+	}
+	log.Out = os.Stdout
+}
+
+type checkoutService struct {
+	pb.UnimplementedCheckoutServiceServer
+
+	productCatalogSvcAddr string
+	productCatalogSvcConn *grpc.ClientConn
+
+	cartSvcAddr string
+	cartSvcConn *grpc.ClientConn
+
+	currencySvcAddr string
+	currencySvcConn *grpc.ClientConn
+
+	shippingSvcAddr string
+	shippingSvcConn *grpc.ClientConn
+
+	emailSvcAddr string
+	emailSvcConn *grpc.ClientConn
+
+	paymentSvcAddr string
+	paymentSvcConn *grpc.ClientConn
+}
+
+func main() {
+	ctx := context.Background()
+	if os.Getenv("ENABLE_TRACING") == "1" {
+		log.Info("Tracing enabled.")
+		initTracing()
+
+	} else {
+		log.Info("Tracing disabled.")
+	}
+
+	if os.Getenv("ENABLE_PROFILER") == "1" {
+		log.Info("Profiling enabled.")
+		go initProfiling("checkoutservice", "1.0.0")
+	} else {
+		log.Info("Profiling disabled.")
+	}
+
+	port := listenPort
+	if os.Getenv("PORT") != "" {
+		port = os.Getenv("PORT")
+	}
+
+	svc := new(checkoutService)
+	mustMapEnv(&svc.shippingSvcAddr, "SHIPPING_SERVICE_ADDR")
+	mustMapEnv(&svc.productCatalogSvcAddr, "PRODUCT_CATALOG_SERVICE_ADDR")
+	mustMapEnv(&svc.cartSvcAddr, "CART_SERVICE_ADDR")
+	mustMapEnv(&svc.currencySvcAddr, "CURRENCY_SERVICE_ADDR")
+	mustMapEnv(&svc.emailSvcAddr, "EMAIL_SERVICE_ADDR")
+	mustMapEnv(&svc.paymentSvcAddr, "PAYMENT_SERVICE_ADDR")
+
+	mustConnGRPC(ctx, &svc.shippingSvcConn, svc.shippingSvcAddr)
+	mustConnGRPC(ctx, &svc.productCatalogSvcConn, svc.productCatalogSvcAddr)
+	mustConnGRPC(ctx, &svc.cartSvcConn, svc.cartSvcAddr)
+	mustConnGRPC(ctx, &svc.currencySvcConn, svc.currencySvcAddr)
+	mustConnGRPC(ctx, &svc.emailSvcConn, svc.emailSvcAddr)
+	mustConnGRPC(ctx, &svc.paymentSvcConn, svc.paymentSvcAddr)
+
+	log.Infof("service config: %+v", svc)
+
+	lis, err := net.Listen("tcp", fmt.Sprintf(":%s", port))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var srv *grpc.Server
+
+	// Propagate trace context always
+	otel.SetTextMapPropagator(
+		propagation.NewCompositeTextMapPropagator(
+			propagation.TraceContext{}, propagation.Baggage{}))
+	srv = grpc.NewServer(
+		grpc.StatsHandler(otelgrpc.NewServerHandler()),
+	)
+
+	pb.RegisterCheckoutServiceServer(srv, svc)
+	healthcheck := health.NewServer()
+	healthpb.RegisterHealthServer(srv, healthcheck)
+	log.Infof("starting to listen on tcp: %q", lis.Addr().String())
+	err = srv.Serve(lis)
+	log.Fatal(err)
+}
+
+func initStats() {
+	//TODO(arbrown) Implement OpenTelemetry stats
+}
+
+func initTracing() {
+	var (
+		collectorAddr string
+		collectorConn *grpc.ClientConn
+	)
+
+	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(ctx, time.Second*3)
+	defer cancel()
+
+	mustMapEnv(&collectorAddr, "COLLECTOR_SERVICE_ADDR")
+	mustConnGRPC(ctx, &collectorConn, collectorAddr)
+
+	exporter, err := otlptracegrpc.New(
+		ctx,
+		otlptracegrpc.WithGRPCConn(collectorConn))
+	if err != nil {
+		log.Warnf("warn: Failed to create trace exporter: %v", err)
+	}
+	tp := sdktrace.NewTracerProvider(
+		sdktrace.WithBatcher(exporter),
+		sdktrace.WithSampler(sdktrace.AlwaysSample()))
+	otel.SetTracerProvider(tp)
+
+}
+
+func initProfiling(service, version string) {
+	// TODO(ahmetb) this method is duplicated in other microservices using Go
+	// since they are not sharing packages.
+	for i := 1; i <= 3; i++ {
+		if err := profiler.Start(profiler.Config{
+			Service:        service,
+			ServiceVersion: version,
+			// ProjectID must be set if not running on GCP.
+			// ProjectID: "my-project",
+		}); err != nil {
+			log.Warnf("failed to start profiler: %+v", err)
+		} else {
+			log.Info("started Stackdriver profiler")
+			return
+		}
+		d := time.Second * 10 * time.Duration(i)
+		log.Infof("sleeping %v to retry initializing Stackdriver profiler", d)
+		time.Sleep(d)
+	}
+	log.Warn("could not initialize Stackdriver profiler after retrying, giving up")
+}
+
+func mustMapEnv(target *string, envKey string) {
+	v := os.Getenv(envKey)
+	if v == "" {
+		panic(fmt.Sprintf("environment variable %q not set", envKey))
+	}
+	*target = v
+}
+
+func mustConnGRPC(ctx context.Context, conn **grpc.ClientConn, addr string) {
+	var err error
+	_, cancel := context.WithTimeout(ctx, time.Second*3)
+	defer cancel()
+	*conn, err = grpc.NewClient(addr,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithStatsHandler(otelgrpc.NewClientHandler()))
+	if err != nil {
+		panic(errors.Wrapf(err, "grpc: failed to connect %s", addr))
+	}
+}
+
+func (cs *checkoutService) Check(ctx context.Context, req *healthpb.HealthCheckRequest) (*healthpb.HealthCheckResponse, error) {
+	return &healthpb.HealthCheckResponse{Status: healthpb.HealthCheckResponse_SERVING}, nil
+}
+
+func (cs *checkoutService) Watch(req *healthpb.HealthCheckRequest, ws healthpb.Health_WatchServer) error {
+	return status.Errorf(codes.Unimplemented, "health check via Watch not implemented")
+}
+
+func (cs *checkoutService) PlaceOrder(ctx context.Context, req *pb.PlaceOrderRequest) (*pb.PlaceOrderResponse, error) {
+	log.Infof("[PlaceOrder] user_id=%q user_currency=%q", req.UserId, req.UserCurrency)
+
+	orderID, err := uuid.NewUUID()
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "failed to generate order uuid")
+	}
+
+	prep, err := cs.prepareOrderItemsAndShippingQuoteFromCart(ctx, req.UserId, req.UserCurrency, req.Address)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+
+	total := pb.Money{CurrencyCode: req.UserCurrency,
+		Units: 0,
+		Nanos: 0}
+	total = money.Must(money.Sum(total, *prep.shippingCostLocalized))
+	for _, it := range prep.orderItems {
+		multPrice := money.MultiplySlow(*it.Cost, uint32(it.GetItem().GetQuantity()))
+		total = money.Must(money.Sum(total, multPrice))
+	}
+
+	txID, err := cs.chargeCard(ctx, &total, req.CreditCard)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "failed to charge card: %+v", err)
+	}
+	log.Infof("payment went through (transaction_id: %s)", txID)
+
+	shippingTrackingID, err := cs.shipOrder(ctx, req.Address, prep.cartItems)
+	if err != nil {
+		return nil, status.Errorf(codes.Unavailable, "shipping error: %+v", err)
+	}
+
+	_ = cs.emptyUserCart(ctx, req.UserId)
+
+	orderResult := &pb.OrderResult{
+		OrderId:            orderID.String(),
+		ShippingTrackingId: shippingTrackingID,
+		ShippingCost:       prep.shippingCostLocalized,
+		ShippingAddress:    req.Address,
+		Items:              prep.orderItems,
+	}
+
+	if err := cs.sendOrderConfirmation(ctx, req.Email, orderResult); err != nil {
+		log.Warnf("failed to send order confirmation to %q: %+v", req.Email, err)
+	} else {
+		log.Infof("order confirmation email sent to %q", req.Email)
+	}
+	resp := &pb.PlaceOrderResponse{Order: orderResult}
+	return resp, nil
+}
+
+type orderPrep struct {
+	orderItems            []*pb.OrderItem
+	cartItems             []*pb.CartItem
+	shippingCostLocalized *pb.Money
+}
+
+func (cs *checkoutService) prepareOrderItemsAndShippingQuoteFromCart(ctx context.Context, userID, userCurrency string, address *pb.Address) (orderPrep, error) {
+	var out orderPrep
+	cartItems, err := cs.getUserCart(ctx, userID)
+	if err != nil {
+		return out, fmt.Errorf("cart failure: %+v", err)
+	}
+	orderItems, err := cs.prepOrderItems(ctx, cartItems, userCurrency)
+	if err != nil {
+		return out, fmt.Errorf("failed to prepare order: %+v", err)
+	}
+	shippingUSD, err := cs.quoteShipping(ctx, address, cartItems)
+	if err != nil {
+		return out, fmt.Errorf("shipping quote failure: %+v", err)
+	}
+	shippingPrice, err := cs.convertCurrency(ctx, shippingUSD, userCurrency)
+	if err != nil {
+		return out, fmt.Errorf("failed to convert shipping cost to currency: %+v", err)
+	}
+
+	out.shippingCostLocalized = shippingPrice
+	out.cartItems = cartItems
+	out.orderItems = orderItems
+	return out, nil
+}
+
+func (cs *checkoutService) quoteShipping(ctx context.Context, address *pb.Address, items []*pb.CartItem) (*pb.Money, error) {
+	shippingQuote, err := pb.NewShippingServiceClient(cs.shippingSvcConn).
+		GetQuote(ctx, &pb.GetQuoteRequest{
+			Address: address,
+			Items:   items})
+	if err != nil {
+		return nil, fmt.Errorf("failed to get shipping quote: %+v", err)
+	}
+	return shippingQuote.GetCostUsd(), nil
+}
+
+func (cs *checkoutService) getUserCart(ctx context.Context, userID string) ([]*pb.CartItem, error) {
+	cart, err := pb.NewCartServiceClient(cs.cartSvcConn).GetCart(ctx, &pb.GetCartRequest{UserId: userID})
+	if err != nil {
+		return nil, fmt.Errorf("failed to get user cart during checkout: %+v", err)
+	}
+	return cart.GetItems(), nil
+}
+
+func (cs *checkoutService) emptyUserCart(ctx context.Context, userID string) error {
+	if _, err := pb.NewCartServiceClient(cs.cartSvcConn).EmptyCart(ctx, &pb.EmptyCartRequest{UserId: userID}); err != nil {
+		return fmt.Errorf("failed to empty user cart during checkout: %+v", err)
+	}
+	return nil
+}
+
+func (cs *checkoutService) prepOrderItems(ctx context.Context, items []*pb.CartItem, userCurrency string) ([]*pb.OrderItem, error) {
+	out := make([]*pb.OrderItem, len(items))
+	cl := pb.NewProductCatalogServiceClient(cs.productCatalogSvcConn)
+
+	for i, item := range items {
+		product, err := cl.GetProduct(ctx, &pb.GetProductRequest{Id: item.GetProductId()})
+		if err != nil {
+			return nil, fmt.Errorf("failed to get product #%q", item.GetProductId())
+		}
+		price, err := cs.convertCurrency(ctx, product.GetPriceUsd(), userCurrency)
+		if err != nil {
+			return nil, fmt.Errorf("failed to convert price of %q to %s", item.GetProductId(), userCurrency)
+		}
+		out[i] = &pb.OrderItem{
+			Item: item,
+			Cost: price}
+	}
+	return out, nil
+}
+
+func (cs *checkoutService) convertCurrency(ctx context.Context, from *pb.Money, toCurrency string) (*pb.Money, error) {
+	result, err := pb.NewCurrencyServiceClient(cs.currencySvcConn).Convert(context.TODO(), &pb.CurrencyConversionRequest{
+		From:   from,
+		ToCode: toCurrency})
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert currency: %+v", err)
+	}
+	return result, err
+}
+
+func (cs *checkoutService) chargeCard(ctx context.Context, amount *pb.Money, paymentInfo *pb.CreditCardInfo) (string, error) {
+	paymentResp, err := pb.NewPaymentServiceClient(cs.paymentSvcConn).Charge(ctx, &pb.ChargeRequest{
+		Amount:     amount,
+		CreditCard: paymentInfo})
+	if err != nil {
+		return "", fmt.Errorf("could not charge the card: %+v", err)
+	}
+	return paymentResp.GetTransactionId(), nil
+}
+
+func (cs *checkoutService) sendOrderConfirmation(ctx context.Context, email string, order *pb.OrderResult) error {
+	_, err := pb.NewEmailServiceClient(cs.emailSvcConn).SendOrderConfirmation(ctx, &pb.SendOrderConfirmationRequest{
+		Email: email,
+		Order: order})
+	return err
+}
+
+func (cs *checkoutService) shipOrder(ctx context.Context, address *pb.Address, items []*pb.CartItem) (string, error) {
+	resp, err := pb.NewShippingServiceClient(cs.shippingSvcConn).ShipOrder(ctx, &pb.ShipOrderRequest{
+		Address: address,
+		Items:   items})
+	if err != nil {
+		return "", fmt.Errorf("shipment failed: %+v", err)
+	}
+	return resp.GetTrackingId(), nil
+}

benchmark/boutique/scheduling/110/code/checkoutservice/money/money.go

@@ -0,0 +1,132 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package money
+
+import (
+	"errors"
+
+	pb "github.com/GoogleCloudPlatform/microservices-demo/src/checkoutservice/genproto"
+)
+
+const (
+	nanosMin = -999999999
+	nanosMax = +999999999
+	nanosMod = 1000000000
+)
+
+var (
+	ErrInvalidValue        = errors.New("one of the specified money values is invalid")
+	ErrMismatchingCurrency = errors.New("mismatching currency codes")
+)
+
+// IsValid checks if specified value has a valid units/nanos signs and ranges.
+func IsValid(m pb.Money) bool {
+	return signMatches(m) && validNanos(m.GetNanos())
+}
+
+func signMatches(m pb.Money) bool {
+	return m.GetNanos() == 0 || m.GetUnits() == 0 || (m.GetNanos() < 0) == (m.GetUnits() < 0)
+}
+
+func validNanos(nanos int32) bool { return nanosMin <= nanos && nanos <= nanosMax }
+
+// IsZero returns true if the specified money value is equal to zero.
+func IsZero(m pb.Money) bool { return m.GetUnits() == 0 && m.GetNanos() == 0 }
+
+// IsPositive returns true if the specified money value is valid and is
+// positive.
+func IsPositive(m pb.Money) bool {
+	return IsValid(m) && m.GetUnits() > 0 || (m.GetUnits() == 0 && m.GetNanos() > 0)
+}
+
+// IsNegative returns true if the specified money value is valid and is
+// negative.
+func IsNegative(m pb.Money) bool {
+	return IsValid(m) && m.GetUnits() < 0 || (m.GetUnits() == 0 && m.GetNanos() < 0)
+}
+
+// AreSameCurrency returns true if values l and r have a currency code and
+// they are the same values.
+func AreSameCurrency(l, r pb.Money) bool {
+	return l.GetCurrencyCode() == r.GetCurrencyCode() && l.GetCurrencyCode() != ""
+}
+
+// AreEquals returns true if values l and r are the equal, including the
+// currency. This does not check validity of the provided values.
+func AreEquals(l, r pb.Money) bool {
+	return l.GetCurrencyCode() == r.GetCurrencyCode() &&
+		l.GetUnits() == r.GetUnits() && l.GetNanos() == r.GetNanos()
+}
+
+// Negate returns the same amount with the sign negated.
+func Negate(m pb.Money) pb.Money {
+	return pb.Money{
+		Units:        -m.GetUnits(),
+		Nanos:        -m.GetNanos(),
+		CurrencyCode: m.GetCurrencyCode()}
+}
+
+// Must panics if the given error is not nil. This can be used with other
+// functions like: "m := Must(Sum(a,b))".
+func Must(v pb.Money, err error) pb.Money {
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Sum adds two values. Returns an error if one of the values are invalid or
+// currency codes are not matching (unless currency code is unspecified for
+// both).
+func Sum(l, r pb.Money) (pb.Money, error) {
+	if !IsValid(l) || !IsValid(r) {
+		return pb.Money{}, ErrInvalidValue
+	} else if l.GetCurrencyCode() != r.GetCurrencyCode() {
+		return pb.Money{}, ErrMismatchingCurrency
+	}
+	units := l.GetUnits() + r.GetUnits()
+	nanos := l.GetNanos() + r.GetNanos()
+
+	if (units == 0 && nanos == 0) || (units > 0 && nanos >= 0) || (units < 0 && nanos <= 0) {
+		// same sign <units, nanos>
+		units += int64(nanos / nanosMod)
+		nanos = nanos % nanosMod
+	} else {
+		// different sign. nanos guaranteed to not to go over the limit
+		if units > 0 {
+			units--
+			nanos += nanosMod
+		} else {
+			units++
+			nanos -= nanosMod
+		}
+	}
+
+	return pb.Money{
+		Units:        units,
+		Nanos:        nanos,
+		CurrencyCode: l.GetCurrencyCode()}, nil
+}
+
+// MultiplySlow is a slow multiplication operation done through adding the value
+// to itself n-1 times.
+func MultiplySlow(m pb.Money, n uint32) pb.Money {
+	out := m
+	for n > 1 {
+		out = Must(Sum(out, m))
+		n--
+	}
+	return out
+}

benchmark/boutique/scheduling/110/code/currencyservice/client.js

@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+require('@google-cloud/trace-agent').start();
+
+const path = require('path');
+const grpc = require('grpc');
+const pino = require('pino');
+
+const PROTO_PATH = path.join(__dirname, './proto/demo.proto');
+const PORT = 7000;
+
+const shopProto = grpc.load(PROTO_PATH).hipstershop;
+const client = new shopProto.CurrencyService(`localhost:${PORT}`,
+  grpc.credentials.createInsecure());
+
+const logger = pino({
+  name: 'currencyservice-client',
+  messageKey: 'message',
+  formatters: {
+    level (logLevelString, logLevelNum) {
+      return { severity: logLevelString }
+    }
+  }
+});
+
+const request = {
+  from: {
+    currency_code: 'CHF',
+    units: 300,
+    nanos: 0
+  },
+  to_code: 'EUR'
+};
+
+function _moneyToString (m) {
+  return `${m.units}.${m.nanos.toString().padStart(9,'0')} ${m.currency_code}`;
+}
+
+client.getSupportedCurrencies({}, (err, response) => {
+  if (err) {
+    logger.error(`Error in getSupportedCurrencies: ${err}`);
+  } else {
+    logger.info(`Currency codes: ${response.currency_codes}`);
+  }
+});
+
+client.convert(request, (err, response) => {
+  if (err) {
+    logger.error(`Error in convert: ${err}`);
+  } else {
+    logger.log(`Convert: ${_moneyToString(request.from)} to ${_moneyToString(response)}`);
+  }
+});

benchmark/boutique/scheduling/110/code/currencyservice/server.js

@@ -0,0 +1,198 @@
+/*
+ * Copyright 2018 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const pino = require('pino');
+const logger = pino({
+  name: 'currencyservice-server',
+  messageKey: 'message',
+  formatters: {
+    level (logLevelString, logLevelNum) {
+      return { severity: logLevelString }
+    }
+  }
+});
+
+if(process.env.DISABLE_PROFILER) {
+  logger.info("Profiler disabled.")
+}
+else {
+  logger.info("Profiler enabled.")
+  require('@google-cloud/profiler').start({
+    serviceContext: {
+      service: 'currencyservice',
+      version: '1.0.0'
+    }
+  });
+}
+
+// Register GRPC OTel Instrumentation for trace propagation
+// regardless of whether tracing is emitted.
+const { GrpcInstrumentation } = require('@opentelemetry/instrumentation-grpc');
+const { registerInstrumentations } = require('@opentelemetry/instrumentation');
+
+registerInstrumentations({
+  instrumentations: [new GrpcInstrumentation()]
+});
+
+if(process.env.ENABLE_TRACING == "1") {
+  logger.info("Tracing enabled.")
+
+  const { resourceFromAttributes } = require('@opentelemetry/resources');
+
+  const { ATTR_SERVICE_NAME } = require('@opentelemetry/semantic-conventions');
+
+  const opentelemetry = require('@opentelemetry/sdk-node');
+
+  const { OTLPTraceExporter } = require('@opentelemetry/exporter-otlp-grpc');
+
+  const collectorUrl = process.env.COLLECTOR_SERVICE_ADDR;
+  const traceExporter = new OTLPTraceExporter({url: collectorUrl});
+  const sdk = new opentelemetry.NodeSDK({
+    resource: resourceFromAttributes({
+      [ ATTR_SERVICE_NAME ]: process.env.OTEL_SERVICE_NAME || 'currencyservice',
+    }),
+    traceExporter: traceExporter,
+  });
+
+  sdk.start()
+}
+else {
+  logger.info("Tracing disabled.")
+}
+
+const path = require('path');
+const grpc = require('@grpc/grpc-js');
+const protoLoader = require('@grpc/proto-loader');
+
+const MAIN_PROTO_PATH = path.join(__dirname, './proto/demo.proto');
+const HEALTH_PROTO_PATH = path.join(__dirname, './proto/grpc/health/v1/health.proto');
+
+const PORT = process.env.PORT;
+
+const shopProto = _loadProto(MAIN_PROTO_PATH).hipstershop;
+const healthProto = _loadProto(HEALTH_PROTO_PATH).grpc.health.v1;
+
+/**
+ * Helper function that loads a protobuf file.
+ */
+function _loadProto (path) {
+  const packageDefinition = protoLoader.loadSync(
+    path,
+    {
+      keepCase: true,
+      longs: String,
+      enums: String,
+      defaults: true,
+      oneofs: true
+    }
+  );
+  return grpc.loadPackageDefinition(packageDefinition);
+}
+
+/**
+ * Helper function that gets currency data from a stored JSON file
+ * Uses public data from European Central Bank
+ */
+function _getCurrencyData (callback) {
+  const data = require('./data/currency_conversion.json');
+  callback(data);
+}
+
+/**
+ * Helper function that handles decimal/fractional carrying
+ */
+function _carry (amount) {
+  const fractionSize = Math.pow(10, 9);
+  amount.nanos += (amount.units % 1) * fractionSize;
+  amount.units = Math.floor(amount.units) + Math.floor(amount.nanos / fractionSize);
+  amount.nanos = amount.nanos % fractionSize;
+  return amount;
+}
+
+/**
+ * Lists the supported currencies
+ */
+function getSupportedCurrencies (call, callback) {
+  logger.info('Getting supported currencies...');
+  _getCurrencyData((data) => {
+    callback(null, {currency_codes: Object.keys(data)});
+  });
+}
+
+/**
+ * Converts between currencies
+ */
+function convert (call, callback) {
+  try {
+    _getCurrencyData((data) => {
+      const request = call.request;
+
+      // Convert: from_currency --> EUR
+      const from = request.from;
+      const euros = _carry({
+        units: from.units / data[from.currency_code],
+        nanos: from.nanos / data[from.currency_code]
+      });
+
+      euros.nanos = Math.round(euros.nanos);
+
+      // Convert: EUR --> to_currency
+      const result = _carry({
+        units: euros.units * data[request.to_code],
+        nanos: euros.nanos * data[request.to_code]
+      });
+
+      result.units = Math.floor(result.units);
+      result.nanos = Math.floor(result.nanos);
+      result.currency_code = request.to_code;
+
+      logger.info(`conversion request successful`);
+      callback(null, result);
+    });
+  } catch (err) {
+    logger.error(`conversion request failed: ${err}`);
+    callback(err.message);
+  }
+}
+
+/**
+ * Endpoint for health checks
+ */
+function check (call, callback) {
+  callback(null, { status: 'SERVING' });
+}
+
+/**
+ * Starts an RPC server that receives requests for the
+ * CurrencyConverter service at the sample server port
+ */
+function main () {
+  logger.info(`Starting gRPC server on port ${PORT}...`);
+  const server = new grpc.Server();
+  server.addService(shopProto.CurrencyService.service, {getSupportedCurrencies, convert});
+  server.addService(healthProto.Health.service, {check});
+
+  server.bindAsync(
+    `[::]:${PORT}`,
+    grpc.ServerCredentials.createInsecure(),
+    function() {
+      logger.info(`CurrencyService gRPC server started on port ${PORT}`);
+      server.start();
+    },
+   );
+}
+
+main();

benchmark/boutique/scheduling/110/code/emailservice/email_client.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python
+#
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import grpc
+
+import demo_pb2
+import demo_pb2_grpc
+
+from logger import getJSONLogger
+logger = getJSONLogger('emailservice-client')
+
+def send_confirmation_email(email, order):
+  channel = grpc.insecure_channel('[::]:8080')
+  stub = demo_pb2_grpc.EmailServiceStub(channel)
+  try:
+    response = stub.SendOrderConfirmation(demo_pb2.SendOrderConfirmationRequest(
+      email = email,
+      order = order
+    ))
+    logger.info('Request sent.')
+  except grpc.RpcError as err:
+    logger.error(err.details())
+    logger.error('{}, {}'.format(err.code().name, err.code().value))
+
+if __name__ == '__main__':
+  logger.info('Client for email service.')

benchmark/boutique/scheduling/110/code/emailservice/email_server.py

@@ -0,0 +1,200 @@
+#!/usr/bin/python
+#
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from concurrent import futures
+import argparse
+import os
+import sys
+import time
+import grpc
+import traceback
+from jinja2 import Environment, FileSystemLoader, select_autoescape, TemplateError
+from google.api_core.exceptions import GoogleAPICallError
+from google.auth.exceptions import DefaultCredentialsError
+
+import demo_pb2
+import demo_pb2_grpc
+from grpc_health.v1 import health_pb2
+from grpc_health.v1 import health_pb2_grpc
+
+from opentelemetry import trace
+from opentelemetry.instrumentation.grpc import GrpcInstrumentorServer
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+
+# @TODO: Temporarily removed in https://github.com/GoogleCloudPlatform/microservices-demo/pull/3196
+# import googlecloudprofiler
+
+from logger import getJSONLogger
+logger = getJSONLogger('emailservice-server')
+
+# Loads confirmation email template from file
+env = Environment(
+    loader=FileSystemLoader('templates'),
+    autoescape=select_autoescape(['html', 'xml'])
+)
+template = env.get_template('confirmation.html')
+
+class BaseEmailService(demo_pb2_grpc.EmailServiceServicer):
+  def Check(self, request, context):
+    return health_pb2.HealthCheckResponse(
+      status=health_pb2.HealthCheckResponse.SERVING)
+  
+  def Watch(self, request, context):
+    return health_pb2.HealthCheckResponse(
+      status=health_pb2.HealthCheckResponse.UNIMPLEMENTED)
+
+class EmailService(BaseEmailService):
+  def __init__(self):
+    raise Exception('cloud mail client not implemented')
+    super().__init__()
+
+  @staticmethod
+  def send_email(client, email_address, content):
+    response = client.send_message(
+      sender = client.sender_path(project_id, region, sender_id),
+      envelope_from_authority = '',
+      header_from_authority = '',
+      envelope_from_address = from_address,
+      simple_message = {
+        "from": {
+          "address_spec": from_address,
+        },
+        "to": [{
+          "address_spec": email_address
+        }],
+        "subject": "Your Confirmation Email",
+        "html_body": content
+      }
+    )
+    logger.info("Message sent: {}".format(response.rfc822_message_id))
+
+  def SendOrderConfirmation(self, request, context):
+    email = request.email
+    order = request.order
+
+    try:
+      confirmation = template.render(order = order)
+    except TemplateError as err:
+      context.set_details("An error occurred when preparing the confirmation mail.")
+      logger.error(err.message)
+      context.set_code(grpc.StatusCode.INTERNAL)
+      return demo_pb2.Empty()
+
+    try:
+      EmailService.send_email(self.client, email, confirmation)
+    except GoogleAPICallError as err:
+      context.set_details("An error occurred when sending the email.")
+      print(err.message)
+      context.set_code(grpc.StatusCode.INTERNAL)
+      return demo_pb2.Empty()
+
+    return demo_pb2.Empty()
+
+class DummyEmailService(BaseEmailService):
+  def SendOrderConfirmation(self, request, context):
+    logger.info('A request to send order confirmation email to {} has been received.'.format(request.email))
+    return demo_pb2.Empty()
+
+class HealthCheck():
+  def Check(self, request, context):
+    return health_pb2.HealthCheckResponse(
+      status=health_pb2.HealthCheckResponse.SERVING)
+
+def start(dummy_mode):
+  server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),)
+  service = None
+  if dummy_mode:
+    service = DummyEmailService()
+  else:
+    raise Exception('non-dummy mode not implemented yet')
+
+  demo_pb2_grpc.add_EmailServiceServicer_to_server(service, server)
+  health_pb2_grpc.add_HealthServicer_to_server(service, server)
+
+  port = os.environ.get('PORT', "8080")
+  logger.info("listening on port: "+port)
+  server.add_insecure_port('[::]:'+port)
+  server.start()
+  try:
+    while True:
+      time.sleep(3600)
+  except KeyboardInterrupt:
+    server.stop(0)
+
+def initStackdriverProfiling():
+  project_id = None
+  try:
+    project_id = os.environ["GCP_PROJECT_ID"]
+  except KeyError:
+    # Environment variable not set
+    pass
+
+  # @TODO: Temporarily removed in https://github.com/GoogleCloudPlatform/microservices-demo/pull/3196
+  # for retry in range(1,4):
+  #   try:
+  #     if project_id:
+  #       googlecloudprofiler.start(service='email_server', service_version='1.0.0', verbose=0, project_id=project_id)
+  #     else:
+  #       googlecloudprofiler.start(service='email_server', service_version='1.0.0', verbose=0)
+  #     logger.info("Successfully started Stackdriver Profiler.")
+  #     return
+  #   except (BaseException) as exc:
+  #     logger.info("Unable to start Stackdriver Profiler Python agent. " + str(exc))
+  #     if (retry < 4):
+  #       logger.info("Sleeping %d to retry initializing Stackdriver Profiler"%(retry*10))
+  #       time.sleep (1)
+  #     else:
+  #       logger.warning("Could not initialize Stackdriver Profiler after retrying, giving up")
+  return
+
+
+if __name__ == '__main__':
+  logger.info('starting the email service in dummy mode.')
+
+  # Profiler
+  try:
+    if "DISABLE_PROFILER" in os.environ:
+      raise KeyError()
+    else:
+      logger.info("Profiler enabled.")
+      initStackdriverProfiling()
+  except KeyError:
+      logger.info("Profiler disabled.")
+
+  # Tracing
+  try:
+    if os.environ["ENABLE_TRACING"] == "1":
+      otel_endpoint = os.getenv("COLLECTOR_SERVICE_ADDR", "localhost:4317")
+      trace.set_tracer_provider(TracerProvider())
+      trace.get_tracer_provider().add_span_processor(
+        BatchSpanProcessor(
+            OTLPSpanExporter(
+            endpoint = otel_endpoint,
+            insecure = True
+          )
+        )
+      )
+    grpc_server_instrumentor = GrpcInstrumentorServer()
+    grpc_server_instrumentor.instrument()
+
+  except (KeyError, DefaultCredentialsError):
+      logger.info("Tracing disabled.")
+  except Exception as e:
+      logger.warn(f"Exception on Cloud Trace setup: {traceback.format_exc()}, tracing disabled.") 
+  
+  start(dummy_mode = True)

benchmark/boutique/scheduling/110/code/emailservice/logger.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python
+#
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import sys
+from pythonjsonlogger import jsonlogger
+
+# TODO(yoshifumi) this class is duplicated since other Python services are
+# not sharing the modules for logging.
+class CustomJsonFormatter(jsonlogger.JsonFormatter):
+  def add_fields(self, log_record, record, message_dict):
+    super(CustomJsonFormatter, self).add_fields(log_record, record, message_dict)
+    if not log_record.get('timestamp'):
+      log_record['timestamp'] = record.created
+    if log_record.get('severity'):
+      log_record['severity'] = log_record['severity'].upper()
+    else:
+      log_record['severity'] = record.levelname
+
+def getJSONLogger(name):
+  logger = logging.getLogger(name)
+  handler = logging.StreamHandler(sys.stdout)
+  formatter = CustomJsonFormatter('%(timestamp)s %(severity)s %(name)s %(message)s')
+  handler.setFormatter(formatter)
+  logger.addHandler(handler)
+  logger.setLevel(logging.INFO)
+  logger.propagate = False
+  return logger

benchmark/boutique/scheduling/110/code/frontend/deployment_details.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"net/http"
+	"os"
+	"time"
+
+	"cloud.google.com/go/compute/metadata"
+	"github.com/sirupsen/logrus"
+)
+
+var deploymentDetailsMap map[string]string
+var log *logrus.Logger
+
+func init() {
+	initializeLogger()
+	// Use a goroutine to ensure loadDeploymentDetails()'s GCP API
+	// calls don't block non-GCP deployments. See issue #685.
+	go loadDeploymentDetails()
+}
+
+func initializeLogger() {
+	log = logrus.New()
+	log.Level = logrus.DebugLevel
+	log.Formatter = &logrus.JSONFormatter{
+		FieldMap: logrus.FieldMap{
+			logrus.FieldKeyTime:  "timestamp",
+			logrus.FieldKeyLevel: "severity",
+			logrus.FieldKeyMsg:   "message",
+		},
+		TimestampFormat: time.RFC3339Nano,
+	}
+	log.Out = os.Stdout
+}
+
+func loadDeploymentDetails() {
+	deploymentDetailsMap = make(map[string]string)
+	var metaServerClient = metadata.NewClient(&http.Client{})
+
+	podHostname, err := os.Hostname()
+	if err != nil {
+		log.Error("Failed to fetch the hostname for the Pod", err)
+	}
+
+	podCluster, err := metaServerClient.InstanceAttributeValue("cluster-name")
+	if err != nil {
+		log.Error("Failed to fetch the name of the cluster in which the pod is running", err)
+	}
+
+	podZone, err := metaServerClient.Zone()
+	if err != nil {
+		log.Error("Failed to fetch the Zone of the node where the pod is scheduled", err)
+	}
+
+	deploymentDetailsMap["HOSTNAME"] = podHostname
+	deploymentDetailsMap["CLUSTERNAME"] = podCluster
+	deploymentDetailsMap["ZONE"] = podZone
+
+	log.WithFields(logrus.Fields{
+		"cluster":  podCluster,
+		"zone":     podZone,
+		"hostname": podHostname,
+	}).Debug("Loaded deployment details")
+}

benchmark/boutique/scheduling/110/code/frontend/handlers.go

@@ -0,0 +1,635 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"html/template"
+	"io"
+	"math/rand"
+	"net"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gorilla/mux"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+
+	pb "github.com/GoogleCloudPlatform/microservices-demo/src/frontend/genproto"
+	"github.com/GoogleCloudPlatform/microservices-demo/src/frontend/money"
+	"github.com/GoogleCloudPlatform/microservices-demo/src/frontend/validator"
+)
+
+type platformDetails struct {
+	css      string
+	provider string
+}
+
+var (
+	frontendMessage  = strings.TrimSpace(os.Getenv("FRONTEND_MESSAGE"))
+	isCymbalBrand    = "true" == strings.ToLower(os.Getenv("CYMBAL_BRANDING"))
+	assistantEnabled = "true" == strings.ToLower(os.Getenv("ENABLE_ASSISTANT"))
+	templates        = template.Must(template.New("").
+				Funcs(template.FuncMap{
+			"renderMoney":        renderMoney,
+			"renderCurrencyLogo": renderCurrencyLogo,
+		}).ParseGlob("templates/*.html"))
+	plat platformDetails
+)
+
+var validEnvs = []string{"local", "gcp", "azure", "aws", "onprem", "alibaba"}
+
+func (fe *frontendServer) homeHandler(w http.ResponseWriter, r *http.Request) {
+	log := r.Context().Value(ctxKeyLog{}).(logrus.FieldLogger)
+	log.WithField("currency", currentCurrency(r)).Info("home")
+	currencies, err := fe.getCurrencies(r.Context())
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve currencies"), http.StatusInternalServerError)
+		return
+	}
+	products, err := fe.getProducts(r.Context())
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve products"), http.StatusInternalServerError)
+		return
+	}
+	cart, err := fe.getCart(r.Context(), sessionID(r))
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve cart"), http.StatusInternalServerError)
+		return
+	}
+
+	type productView struct {
+		Item  *pb.Product
+		Price *pb.Money
+	}
+	ps := make([]productView, len(products))
+	for i, p := range products {
+		price, err := fe.convertCurrency(r.Context(), p.GetPriceUsd(), currentCurrency(r))
+		if err != nil {
+			renderHTTPError(log, r, w, errors.Wrapf(err, "failed to do currency conversion for product %s", p.GetId()), http.StatusInternalServerError)
+			return
+		}
+		ps[i] = productView{p, price}
+	}
+
+	// Set ENV_PLATFORM (default to local if not set; use env var if set; otherwise detect GCP, which overrides env)_
+	var env = os.Getenv("ENV_PLATFORM")
+	// Only override from env variable if set + valid env
+	if env == "" || stringinSlice(validEnvs, env) == false {
+		fmt.Println("env platform is either empty or invalid")
+		env = "local"
+	}
+	// Autodetect GCP
+	addrs, err := net.LookupHost("metadata.google.internal.")
+	if err == nil && len(addrs) >= 0 {
+		log.Debugf("Detected Google metadata server: %v, setting ENV_PLATFORM to GCP.", addrs)
+		env = "gcp"
+	}
+
+	log.Debugf("ENV_PLATFORM is: %s", env)
+	plat = platformDetails{}
+	plat.setPlatformDetails(strings.ToLower(env))
+
+	if err := templates.ExecuteTemplate(w, "home", injectCommonTemplateData(r, map[string]interface{}{
+		"show_currency": true,
+		"currencies":    currencies,
+		"products":      ps,
+		"cart_size":     cartSize(cart),
+		"banner_color":  os.Getenv("BANNER_COLOR"), // illustrates canary deployments
+		"ad":            fe.chooseAd(r.Context(), []string{}, log),
+	})); err != nil {
+		log.Error(err)
+	}
+}
+
+func (plat *platformDetails) setPlatformDetails(env string) {
+	if env == "aws" {
+		plat.provider = "AWS"
+		plat.css = "aws-platform"
+	} else if env == "onprem" {
+		plat.provider = "On-Premises"
+		plat.css = "onprem-platform"
+	} else if env == "azure" {
+		plat.provider = "Azure"
+		plat.css = "azure-platform"
+	} else if env == "gcp" {
+		plat.provider = "Google Cloud"
+		plat.css = "gcp-platform"
+	} else if env == "alibaba" {
+		plat.provider = "Alibaba Cloud"
+		plat.css = "alibaba-platform"
+	} else {
+		plat.provider = "local"
+		plat.css = "local"
+	}
+}
+
+func (fe *frontendServer) productHandler(w http.ResponseWriter, r *http.Request) {
+	log := r.Context().Value(ctxKeyLog{}).(logrus.FieldLogger)
+	id := mux.Vars(r)["id"]
+	if id == "" {
+		renderHTTPError(log, r, w, errors.New("product id not specified"), http.StatusBadRequest)
+		return
+	}
+	log.WithField("id", id).WithField("currency", currentCurrency(r)).
+		Debug("serving product page")
+
+	p, err := fe.getProduct(r.Context(), id)
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve product"), http.StatusInternalServerError)
+		return
+	}
+	currencies, err := fe.getCurrencies(r.Context())
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve currencies"), http.StatusInternalServerError)
+		return
+	}
+
+	cart, err := fe.getCart(r.Context(), sessionID(r))
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve cart"), http.StatusInternalServerError)
+		return
+	}
+
+	price, err := fe.convertCurrency(r.Context(), p.GetPriceUsd(), currentCurrency(r))
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "failed to convert currency"), http.StatusInternalServerError)
+		return
+	}
+
+	// ignores the error retrieving recommendations since it is not critical
+	recommendations, err := fe.getRecommendations(r.Context(), sessionID(r), []string{id})
+	if err != nil {
+		log.WithField("error", err).Warn("failed to get product recommendations")
+	}
+
+	product := struct {
+		Item  *pb.Product
+		Price *pb.Money
+	}{p, price}
+
+	// Fetch packaging info (weight/dimensions) of the product
+	// The packaging service is an optional microservice you can run as part of a Google Cloud demo.
+	var packagingInfo *PackagingInfo = nil
+	if isPackagingServiceConfigured() {
+		packagingInfo, err = httpGetPackagingInfo(id)
+		if err != nil {
+			fmt.Println("Failed to obtain product's packaging info:", err)
+		}
+	}
+
+	if err := templates.ExecuteTemplate(w, "product", injectCommonTemplateData(r, map[string]interface{}{
+		"ad":              fe.chooseAd(r.Context(), p.Categories, log),
+		"show_currency":   true,
+		"currencies":      currencies,
+		"product":         product,
+		"recommendations": recommendations,
+		"cart_size":       cartSize(cart),
+		"packagingInfo":   packagingInfo,
+	})); err != nil {
+		log.Println(err)
+	}
+}
+
+func (fe *frontendServer) addToCartHandler(w http.ResponseWriter, r *http.Request) {
+	log := r.Context().Value(ctxKeyLog{}).(logrus.FieldLogger)
+	quantity, _ := strconv.ParseUint(r.FormValue("quantity"), 10, 32)
+	productID := r.FormValue("product_id")
+	payload := validator.AddToCartPayload{
+		Quantity:  quantity,
+		ProductID: productID,
+	}
+	if err := payload.Validate(); err != nil {
+		renderHTTPError(log, r, w, validator.ValidationErrorResponse(err), http.StatusUnprocessableEntity)
+		return
+	}
+	log.WithField("product", payload.ProductID).WithField("quantity", payload.Quantity).Debug("adding to cart")
+
+	p, err := fe.getProduct(r.Context(), payload.ProductID)
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve product"), http.StatusInternalServerError)
+		return
+	}
+
+	if err := fe.insertCart(r.Context(), sessionID(r), p.GetId(), int32(payload.Quantity)); err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "failed to add to cart"), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("location", baseUrl + "/cart")
+	w.WriteHeader(http.StatusFound)
+}
+
+func (fe *frontendServer) emptyCartHandler(w http.ResponseWriter, r *http.Request) {
+	log := r.Context().Value(ctxKeyLog{}).(logrus.FieldLogger)
+	log.Debug("emptying cart")
+
+	if err := fe.emptyCart(r.Context(), sessionID(r)); err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "failed to empty cart"), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("location", baseUrl + "/")
+	w.WriteHeader(http.StatusFound)
+}
+
+func (fe *frontendServer) viewCartHandler(w http.ResponseWriter, r *http.Request) {
+	log := r.Context().Value(ctxKeyLog{}).(logrus.FieldLogger)
+	log.Debug("view user cart")
+	currencies, err := fe.getCurrencies(r.Context())
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve currencies"), http.StatusInternalServerError)
+		return
+	}
+	cart, err := fe.getCart(r.Context(), sessionID(r))
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve cart"), http.StatusInternalServerError)
+		return
+	}
+
+	// ignores the error retrieving recommendations since it is not critical
+	recommendations, err := fe.getRecommendations(r.Context(), sessionID(r), cartIDs(cart))
+	if err != nil {
+		log.WithField("error", err).Warn("failed to get product recommendations")
+	}
+
+	shippingCost, err := fe.getShippingQuote(r.Context(), cart, currentCurrency(r))
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "failed to get shipping quote"), http.StatusInternalServerError)
+		return
+	}
+
+	type cartItemView struct {
+		Item     *pb.Product
+		Quantity int32
+		Price    *pb.Money
+	}
+	items := make([]cartItemView, len(cart))
+	totalPrice := pb.Money{CurrencyCode: currentCurrency(r)}
+	for i, item := range cart {
+		p, err := fe.getProduct(r.Context(), item.GetProductId())
+		if err != nil {
+			renderHTTPError(log, r, w, errors.Wrapf(err, "could not retrieve product #%s", item.GetProductId()), http.StatusInternalServerError)
+			return
+		}
+		price, err := fe.convertCurrency(r.Context(), p.GetPriceUsd(), currentCurrency(r))
+		if err != nil {
+			renderHTTPError(log, r, w, errors.Wrapf(err, "could not convert currency for product #%s", item.GetProductId()), http.StatusInternalServerError)
+			return
+		}
+
+		multPrice := money.MultiplySlow(*price, uint32(item.GetQuantity()))
+		items[i] = cartItemView{
+			Item:     p,
+			Quantity: item.GetQuantity(),
+			Price:    &multPrice}
+		totalPrice = money.Must(money.Sum(totalPrice, multPrice))
+	}
+	totalPrice = money.Must(money.Sum(totalPrice, *shippingCost))
+	year := time.Now().Year()
+
+	if err := templates.ExecuteTemplate(w, "cart", injectCommonTemplateData(r, map[string]interface{}{
+		"currencies":       currencies,
+		"recommendations":  recommendations,
+		"cart_size":        cartSize(cart),
+		"shipping_cost":    shippingCost,
+		"show_currency":    true,
+		"total_cost":       totalPrice,
+		"items":            items,
+		"expiration_years": []int{year, year + 1, year + 2, year + 3, year + 4},
+	})); err != nil {
+		log.Println(err)
+	}
+}
+
+func (fe *frontendServer) placeOrderHandler(w http.ResponseWriter, r *http.Request) {
+	log := r.Context().Value(ctxKeyLog{}).(logrus.FieldLogger)
+	log.Debug("placing order")
+
+	var (
+		email         = r.FormValue("email")
+		streetAddress = r.FormValue("street_address")
+		zipCode, _    = strconv.ParseInt(r.FormValue("zip_code"), 10, 32)
+		city          = r.FormValue("city")
+		state         = r.FormValue("state")
+		country       = r.FormValue("country")
+		ccNumber      = r.FormValue("credit_card_number")
+		ccMonth, _    = strconv.ParseInt(r.FormValue("credit_card_expiration_month"), 10, 32)
+		ccYear, _     = strconv.ParseInt(r.FormValue("credit_card_expiration_year"), 10, 32)
+		ccCVV, _      = strconv.ParseInt(r.FormValue("credit_card_cvv"), 10, 32)
+	)
+
+	payload := validator.PlaceOrderPayload{
+		Email:         email,
+		StreetAddress: streetAddress,
+		ZipCode:       zipCode,
+		City:          city,
+		State:         state,
+		Country:       country,
+		CcNumber:      ccNumber,
+		CcMonth:       ccMonth,
+		CcYear:        ccYear,
+		CcCVV:         ccCVV,
+	}
+	if err := payload.Validate(); err != nil {
+		renderHTTPError(log, r, w, validator.ValidationErrorResponse(err), http.StatusUnprocessableEntity)
+		return
+	}
+
+	order, err := pb.NewCheckoutServiceClient(fe.checkoutSvcConn).
+		PlaceOrder(r.Context(), &pb.PlaceOrderRequest{
+			Email: payload.Email,
+			CreditCard: &pb.CreditCardInfo{
+				CreditCardNumber:          payload.CcNumber,
+				CreditCardExpirationMonth: int32(payload.CcMonth),
+				CreditCardExpirationYear:  int32(payload.CcYear),
+				CreditCardCvv:             int32(payload.CcCVV)},
+			UserId:       sessionID(r),
+			UserCurrency: currentCurrency(r),
+			Address: &pb.Address{
+				StreetAddress: payload.StreetAddress,
+				City:          payload.City,
+				State:         payload.State,
+				ZipCode:       int32(payload.ZipCode),
+				Country:       payload.Country},
+		})
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "failed to complete the order"), http.StatusInternalServerError)
+		return
+	}
+	log.WithField("order", order.GetOrder().GetOrderId()).Info("order placed")
+
+	order.GetOrder().GetItems()
+	recommendations, _ := fe.getRecommendations(r.Context(), sessionID(r), nil)
+
+	totalPaid := *order.GetOrder().GetShippingCost()
+	for _, v := range order.GetOrder().GetItems() {
+		multPrice := money.MultiplySlow(*v.GetCost(), uint32(v.GetItem().GetQuantity()))
+		totalPaid = money.Must(money.Sum(totalPaid, multPrice))
+	}
+
+	currencies, err := fe.getCurrencies(r.Context())
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve currencies"), http.StatusInternalServerError)
+		return
+	}
+
+	if err := templates.ExecuteTemplate(w, "order", injectCommonTemplateData(r, map[string]interface{}{
+		"show_currency":   false,
+		"currencies":      currencies,
+		"order":           order.GetOrder(),
+		"total_paid":      &totalPaid,
+		"recommendations": recommendations,
+	})); err != nil {
+		log.Println(err)
+	}
+}
+
+func (fe *frontendServer) assistantHandler(w http.ResponseWriter, r *http.Request) {
+	currencies, err := fe.getCurrencies(r.Context())
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "could not retrieve currencies"), http.StatusInternalServerError)
+		return
+	}
+
+	if err := templates.ExecuteTemplate(w, "assistant", injectCommonTemplateData(r, map[string]interface{}{
+		"show_currency": false,
+		"currencies":    currencies,
+	})); err != nil {
+		log.Println(err)
+	}
+}
+
+func (fe *frontendServer) logoutHandler(w http.ResponseWriter, r *http.Request) {
+	log := r.Context().Value(ctxKeyLog{}).(logrus.FieldLogger)
+	log.Debug("logging out")
+	for _, c := range r.Cookies() {
+		c.Expires = time.Now().Add(-time.Hour * 24 * 365)
+		c.MaxAge = -1
+		http.SetCookie(w, c)
+	}
+	w.Header().Set("Location", baseUrl + "/")
+	w.WriteHeader(http.StatusFound)
+}
+
+func (fe *frontendServer) getProductByID(w http.ResponseWriter, r *http.Request) {
+	id := mux.Vars(r)["ids"]
+	if id == "" {
+		return
+	}
+
+	p, err := fe.getProduct(r.Context(), id)
+	if err != nil {
+		return
+	}
+
+	jsonData, err := json.Marshal(p)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	w.Write(jsonData)
+	w.WriteHeader(http.StatusOK)
+}
+
+func (fe *frontendServer) chatBotHandler(w http.ResponseWriter, r *http.Request) {
+	log := r.Context().Value(ctxKeyLog{}).(logrus.FieldLogger)
+	type Response struct {
+		Message string `json:"message"`
+	}
+
+	type LLMResponse struct {
+		Content string         `json:"content"`
+		Details map[string]any `json:"details"`
+	}
+
+	var response LLMResponse
+
+	url := "http://" + fe.shoppingAssistantSvcAddr
+	req, err := http.NewRequest(http.MethodPost, url, r.Body)
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "failed to create request"), http.StatusInternalServerError)
+		return
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "failed to send request"), http.StatusInternalServerError)
+		return
+	}
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "failed to read response"), http.StatusInternalServerError)
+		return
+	}
+
+	fmt.Printf("%+v\n", body)
+	fmt.Printf("%+v\n", res)
+
+	err = json.Unmarshal(body, &response)
+	if err != nil {
+		renderHTTPError(log, r, w, errors.Wrap(err, "failed to unmarshal body"), http.StatusInternalServerError)
+		return
+	}
+
+	// respond with the same message
+	json.NewEncoder(w).Encode(Response{Message: response.Content})
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (fe *frontendServer) setCurrencyHandler(w http.ResponseWriter, r *http.Request) {
+	log := r.Context().Value(ctxKeyLog{}).(logrus.FieldLogger)
+	cur := r.FormValue("currency_code")
+	payload := validator.SetCurrencyPayload{Currency: cur}
+	if err := payload.Validate(); err != nil {
+		renderHTTPError(log, r, w, validator.ValidationErrorResponse(err), http.StatusUnprocessableEntity)
+		return
+	}
+	log.WithField("curr.new", payload.Currency).WithField("curr.old", currentCurrency(r)).
+		Debug("setting currency")
+
+	if payload.Currency != "" {
+		http.SetCookie(w, &http.Cookie{
+			Name:   cookieCurrency,
+			Value:  payload.Currency,
+			MaxAge: cookieMaxAge,
+		})
+	}
+	referer := r.Header.Get("referer")
+	if referer == "" {
+		referer = baseUrl + "/"
+	}
+	w.Header().Set("Location", referer)
+	w.WriteHeader(http.StatusFound)
+}
+
+// chooseAd queries for advertisements available and randomly chooses one, if
+// available. It ignores the error retrieving the ad since it is not critical.
+func (fe *frontendServer) chooseAd(ctx context.Context, ctxKeys []string, log logrus.FieldLogger) *pb.Ad {
+	ads, err := fe.getAd(ctx, ctxKeys)
+	if err != nil {
+		log.WithField("error", err).Warn("failed to retrieve ads")
+		return nil
+	}
+	return ads[rand.Intn(len(ads))]
+}
+
+func renderHTTPError(log logrus.FieldLogger, r *http.Request, w http.ResponseWriter, err error, code int) {
+	log.WithField("error", err).Error("request error")
+	errMsg := fmt.Sprintf("%+v", err)
+
+	w.WriteHeader(code)
+
+	if templateErr := templates.ExecuteTemplate(w, "error", injectCommonTemplateData(r, map[string]interface{}{
+		"error":       errMsg,
+		"status_code": code,
+		"status":      http.StatusText(code),
+	})); templateErr != nil {
+		log.Println(templateErr)
+	}
+}
+
+func injectCommonTemplateData(r *http.Request, payload map[string]interface{}) map[string]interface{} {
+	data := map[string]interface{}{
+		"session_id":        sessionID(r),
+		"request_id":        r.Context().Value(ctxKeyRequestID{}),
+		"user_currency":     currentCurrency(r),
+		"platform_css":      plat.css,
+		"platform_name":     plat.provider,
+		"is_cymbal_brand":   isCymbalBrand,
+		"assistant_enabled": assistantEnabled,
+		"deploymentDetails": deploymentDetailsMap,
+		"frontendMessage":   frontendMessage,
+		"currentYear":       time.Now().Year(),
+		"baseUrl":           baseUrl,
+	}
+
+	for k, v := range payload {
+		data[k] = v
+	}
+
+	return data
+}
+
+func currentCurrency(r *http.Request) string {
+	c, _ := r.Cookie(cookieCurrency)
+	if c != nil {
+		return c.Value
+	}
+	return defaultCurrency
+}
+
+func sessionID(r *http.Request) string {
+	v := r.Context().Value(ctxKeySessionID{})
+	if v != nil {
+		return v.(string)
+	}
+	return ""
+}
+
+func cartIDs(c []*pb.CartItem) []string {
+	out := make([]string, len(c))
+	for i, v := range c {
+		out[i] = v.GetProductId()
+	}
+	return out
+}
+
+// get total # of items in cart
+func cartSize(c []*pb.CartItem) int {
+	cartSize := 0
+	for _, item := range c {
+		cartSize += int(item.GetQuantity())
+	}
+	return cartSize
+}
+
+func renderMoney(money pb.Money) string {
+	currencyLogo := renderCurrencyLogo(money.GetCurrencyCode())
+	return fmt.Sprintf("%s%d.%02d", currencyLogo, money.GetUnits(), money.GetNanos()/10000000)
+}
+
+func renderCurrencyLogo(currencyCode string) string {
+	logos := map[string]string{
+		"USD": "$",
+		"CAD": "$",
+		"JPY": "¥",
+		"EUR": "€",
+		"TRY": "₺",
+		"GBP": "£",
+	}
+
+	logo := "$" //default
+	if val, ok := logos[currencyCode]; ok {
+		logo = val
+	}
+	return logo
+}
+
+func stringinSlice(slice []string, val string) bool {
+	for _, item := range slice {
+		if item == val {
+			return true
+		}
+	}
+	return false
+}

benchmark/boutique/scheduling/110/code/frontend/main.go

@@ -0,0 +1,235 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"time"
+
+	"cloud.google.com/go/profiler"
+	"github.com/gorilla/mux"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/propagation"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+const (
+	port            = "8080"
+	defaultCurrency = "USD"
+	cookieMaxAge    = 60 * 60 * 48
+
+	cookiePrefix    = "shop_"
+	cookieSessionID = cookiePrefix + "session-id"
+	cookieCurrency  = cookiePrefix + "currency"
+)
+
+var (
+	whitelistedCurrencies = map[string]bool{
+		"USD": true,
+		"EUR": true,
+		"CAD": true,
+		"JPY": true,
+		"GBP": true,
+		"TRY": true,
+	}
+
+	baseUrl = ""
+)
+
+type ctxKeySessionID struct{}
+
+type frontendServer struct {
+	productCatalogSvcAddr string
+	productCatalogSvcConn *grpc.ClientConn
+
+	currencySvcAddr string
+	currencySvcConn *grpc.ClientConn
+
+	cartSvcAddr string
+	cartSvcConn *grpc.ClientConn
+
+	recommendationSvcAddr string
+	recommendationSvcConn *grpc.ClientConn
+
+	checkoutSvcAddr string
+	checkoutSvcConn *grpc.ClientConn
+
+	shippingSvcAddr string
+	shippingSvcConn *grpc.ClientConn
+
+	adSvcAddr string
+	adSvcConn *grpc.ClientConn
+
+	collectorAddr string
+	collectorConn *grpc.ClientConn
+
+	shoppingAssistantSvcAddr string
+}
+
+func main() {
+	ctx := context.Background()
+	log := logrus.New()
+	log.Level = logrus.DebugLevel
+	log.Formatter = &logrus.JSONFormatter{
+		FieldMap: logrus.FieldMap{
+			logrus.FieldKeyTime:  "timestamp",
+			logrus.FieldKeyLevel: "severity",
+			logrus.FieldKeyMsg:   "message",
+		},
+		TimestampFormat: time.RFC3339Nano,
+	}
+	log.Out = os.Stdout
+
+	svc := new(frontendServer)
+
+	otel.SetTextMapPropagator(
+		propagation.NewCompositeTextMapPropagator(
+			propagation.TraceContext{}, propagation.Baggage{}))
+
+	baseUrl = os.Getenv("BASE_URL")
+
+	if os.Getenv("ENABLE_TRACING") == "1" {
+		log.Info("Tracing enabled.")
+		initTracing(log, ctx, svc)
+	} else {
+		log.Info("Tracing disabled.")
+	}
+
+	if os.Getenv("ENABLE_PROFILER") == "1" {
+		log.Info("Profiling enabled.")
+		go initProfiling(log, "frontend", "1.0.0")
+	} else {
+		log.Info("Profiling disabled.")
+	}
+
+	srvPort := port
+	if os.Getenv("PORT") != "" {
+		srvPort = os.Getenv("PORT")
+	}
+	addr := os.Getenv("LISTEN_ADDR")
+	mustMapEnv(&svc.productCatalogSvcAddr, "PRODUCT_CATALOG_SERVICE_ADDR")
+	mustMapEnv(&svc.currencySvcAddr, "CURRENCY_SERVICE_ADDR")
+	mustMapEnv(&svc.cartSvcAddr, "CART_SERVICE_ADDR")
+	mustMapEnv(&svc.recommendationSvcAddr, "RECOMMENDATION_SERVICE_ADDR")
+	mustMapEnv(&svc.checkoutSvcAddr, "CHECKOUT_SERVICE_ADDR")
+	mustMapEnv(&svc.shippingSvcAddr, "SHIPPING_SERVICE_ADDR")
+	mustMapEnv(&svc.adSvcAddr, "AD_SERVICE_ADDR")
+	mustMapEnv(&svc.shoppingAssistantSvcAddr, "SHOPPING_ASSISTANT_SERVICE_ADDR")
+
+	mustConnGRPC(ctx, &svc.currencySvcConn, svc.currencySvcAddr)
+	mustConnGRPC(ctx, &svc.productCatalogSvcConn, svc.productCatalogSvcAddr)
+	mustConnGRPC(ctx, &svc.cartSvcConn, svc.cartSvcAddr)
+	mustConnGRPC(ctx, &svc.recommendationSvcConn, svc.recommendationSvcAddr)
+	mustConnGRPC(ctx, &svc.shippingSvcConn, svc.shippingSvcAddr)
+	mustConnGRPC(ctx, &svc.checkoutSvcConn, svc.checkoutSvcAddr)
+	mustConnGRPC(ctx, &svc.adSvcConn, svc.adSvcAddr)
+
+	r := mux.NewRouter()
+	r.HandleFunc(baseUrl+"/", svc.homeHandler).Methods(http.MethodGet, http.MethodHead)
+	r.HandleFunc(baseUrl+"/product/{id}", svc.productHandler).Methods(http.MethodGet, http.MethodHead)
+	r.HandleFunc(baseUrl+"/cart", svc.viewCartHandler).Methods(http.MethodGet, http.MethodHead)
+	r.HandleFunc(baseUrl+"/cart", svc.addToCartHandler).Methods(http.MethodPost)
+	r.HandleFunc(baseUrl+"/cart/empty", svc.emptyCartHandler).Methods(http.MethodPost)
+	r.HandleFunc(baseUrl+"/setCurrency", svc.setCurrencyHandler).Methods(http.MethodPost)
+	r.HandleFunc(baseUrl+"/logout", svc.logoutHandler).Methods(http.MethodGet)
+	r.HandleFunc(baseUrl+"/cart/checkout", svc.placeOrderHandler).Methods(http.MethodPost)
+	r.HandleFunc(baseUrl+"/assistant", svc.assistantHandler).Methods(http.MethodGet)
+	r.PathPrefix(baseUrl + "/static/").Handler(http.StripPrefix(baseUrl+"/static/", http.FileServer(http.Dir("./static/"))))
+	r.HandleFunc(baseUrl+"/robots.txt", func(w http.ResponseWriter, _ *http.Request) { fmt.Fprint(w, "User-agent: *\nDisallow: /") })
+	r.HandleFunc(baseUrl+"/_healthz", func(w http.ResponseWriter, _ *http.Request) { fmt.Fprint(w, "ok") })
+	r.HandleFunc(baseUrl+"/product-meta/{ids}", svc.getProductByID).Methods(http.MethodGet)
+	r.HandleFunc(baseUrl+"/bot", svc.chatBotHandler).Methods(http.MethodPost)
+
+	var handler http.Handler = r
+	handler = &logHandler{log: log, next: handler}     // add logging
+	handler = ensureSessionID(handler)                 // add session ID
+	handler = otelhttp.NewHandler(handler, "frontend") // add OTel tracing
+
+	log.Infof("starting server on %s:%s", addr, srvPort)
+	log.Fatal(http.ListenAndServe(addr+":"+srvPort, handler))
+}
+func initStats(log logrus.FieldLogger) {
+	// TODO(arbrown) Implement OpenTelemtry stats
+}
+
+func initTracing(log logrus.FieldLogger, ctx context.Context, svc *frontendServer) (*sdktrace.TracerProvider, error) {
+	mustMapEnv(&svc.collectorAddr, "COLLECTOR_SERVICE_ADDR")
+	mustConnGRPC(ctx, &svc.collectorConn, svc.collectorAddr)
+	exporter, err := otlptracegrpc.New(
+		ctx,
+		otlptracegrpc.WithGRPCConn(svc.collectorConn))
+	if err != nil {
+		log.Warnf("warn: Failed to create trace exporter: %v", err)
+	}
+	tp := sdktrace.NewTracerProvider(
+		sdktrace.WithBatcher(exporter),
+		sdktrace.WithSampler(sdktrace.AlwaysSample()))
+	otel.SetTracerProvider(tp)
+
+	return tp, err
+}
+
+func initProfiling(log logrus.FieldLogger, service, version string) {
+	// TODO(ahmetb) this method is duplicated in other microservices using Go
+	// since they are not sharing packages.
+	for i := 1; i <= 3; i++ {
+		log = log.WithField("retry", i)
+		if err := profiler.Start(profiler.Config{
+			Service:        service,
+			ServiceVersion: version,
+			// ProjectID must be set if not running on GCP.
+			// ProjectID: "my-project",
+		}); err != nil {
+			log.Warnf("warn: failed to start profiler: %+v", err)
+		} else {
+			log.Info("started Stackdriver profiler")
+			return
+		}
+		d := time.Second * 10 * time.Duration(i)
+		log.Debugf("sleeping %v to retry initializing Stackdriver profiler", d)
+		time.Sleep(d)
+	}
+	log.Warn("warning: could not initialize Stackdriver profiler after retrying, giving up")
+}
+
+func mustMapEnv(target *string, envKey string) {
+	v := os.Getenv(envKey)
+	if v == "" {
+		panic(fmt.Sprintf("environment variable %q not set", envKey))
+	}
+	*target = v
+}
+
+func mustConnGRPC(ctx context.Context, conn **grpc.ClientConn, addr string) {
+	var err error
+	_, cancel := context.WithTimeout(ctx, time.Second*3)
+	defer cancel()
+	*conn, err = grpc.NewClient(addr,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithStatsHandler(otelgrpc.NewClientHandler()))
+	if err != nil {
+		panic(errors.Wrapf(err, "grpc: failed to connect %s", addr))
+	}
+}

benchmark/boutique/scheduling/110/code/frontend/middleware.go

@@ -0,0 +1,111 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"net/http"
+	"time"
+	"os"
+
+	"github.com/google/uuid"
+	"github.com/sirupsen/logrus"
+)
+
+type ctxKeyLog struct{}
+type ctxKeyRequestID struct{}
+
+type logHandler struct {
+	log  *logrus.Logger
+	next http.Handler
+}
+
+type responseRecorder struct {
+	b      int
+	status int
+	w      http.ResponseWriter
+}
+
+func (r *responseRecorder) Header() http.Header { return r.w.Header() }
+
+func (r *responseRecorder) Write(p []byte) (int, error) {
+	if r.status == 0 {
+		r.status = http.StatusOK
+	}
+	n, err := r.w.Write(p)
+	r.b += n
+	return n, err
+}
+
+func (r *responseRecorder) WriteHeader(statusCode int) {
+	r.status = statusCode
+	r.w.WriteHeader(statusCode)
+}
+
+func (lh *logHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	requestID, _ := uuid.NewRandom()
+	ctx = context.WithValue(ctx, ctxKeyRequestID{}, requestID.String())
+
+	start := time.Now()
+	rr := &responseRecorder{w: w}
+	log := lh.log.WithFields(logrus.Fields{
+		"http.req.path":   r.URL.Path,
+		"http.req.method": r.Method,
+		"http.req.id":     requestID.String(),
+	})
+	if v, ok := r.Context().Value(ctxKeySessionID{}).(string); ok {
+		log = log.WithField("session", v)
+	}
+	log.Debug("request started")
+	defer func() {
+		log.WithFields(logrus.Fields{
+			"http.resp.took_ms": int64(time.Since(start) / time.Millisecond),
+			"http.resp.status":  rr.status,
+			"http.resp.bytes":   rr.b}).Debugf("request complete")
+	}()
+
+	ctx = context.WithValue(ctx, ctxKeyLog{}, log)
+	r = r.WithContext(ctx)
+	lh.next.ServeHTTP(rr, r)
+}
+
+func ensureSessionID(next http.Handler) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var sessionID string
+		c, err := r.Cookie(cookieSessionID)
+		if err == http.ErrNoCookie {
+			if os.Getenv("ENABLE_SINGLE_SHARED_SESSION") == "true" {
+				// Hard coded user id, shared across sessions
+				sessionID = "12345678-1234-1234-1234-123456789123"
+			} else {
+				u, _ := uuid.NewRandom()
+				sessionID = u.String()
+			}
+			http.SetCookie(w, &http.Cookie{
+				Name:   cookieSessionID,
+				Value:  sessionID,
+				MaxAge: cookieMaxAge,
+			})
+		} else if err != nil {
+			return
+		} else {
+			sessionID = c.Value
+		}
+		ctx := context.WithValue(r.Context(), ctxKeySessionID{}, sessionID)
+		r = r.WithContext(ctx)
+		next.ServeHTTP(w, r)
+	}
+}

benchmark/boutique/scheduling/110/code/frontend/money/money.go

@@ -0,0 +1,132 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package money
+
+import (
+	"errors"
+
+	pb "github.com/GoogleCloudPlatform/microservices-demo/src/frontend/genproto"
+)
+
+const (
+	nanosMin = -999999999
+	nanosMax = +999999999
+	nanosMod = 1000000000
+)
+
+var (
+	ErrInvalidValue        = errors.New("one of the specified money values is invalid")
+	ErrMismatchingCurrency = errors.New("mismatching currency codes")
+)
+
+// IsValid checks if specified value has a valid units/nanos signs and ranges.
+func IsValid(m pb.Money) bool {
+	return signMatches(m) && validNanos(m.GetNanos())
+}
+
+func signMatches(m pb.Money) bool {
+	return m.GetNanos() == 0 || m.GetUnits() == 0 || (m.GetNanos() < 0) == (m.GetUnits() < 0)
+}
+
+func validNanos(nanos int32) bool { return nanosMin <= nanos && nanos <= nanosMax }
+
+// IsZero returns true if the specified money value is equal to zero.
+func IsZero(m pb.Money) bool { return m.GetUnits() == 0 && m.GetNanos() == 0 }
+
+// IsPositive returns true if the specified money value is valid and is
+// positive.
+func IsPositive(m pb.Money) bool {
+	return IsValid(m) && m.GetUnits() > 0 || (m.GetUnits() == 0 && m.GetNanos() > 0)
+}
+
+// IsNegative returns true if the specified money value is valid and is
+// negative.
+func IsNegative(m pb.Money) bool {
+	return IsValid(m) && m.GetUnits() < 0 || (m.GetUnits() == 0 && m.GetNanos() < 0)
+}
+
+// AreSameCurrency returns true if values l and r have a currency code and
+// they are the same values.
+func AreSameCurrency(l, r pb.Money) bool {
+	return l.GetCurrencyCode() == r.GetCurrencyCode() && l.GetCurrencyCode() != ""
+}
+
+// AreEquals returns true if values l and r are the equal, including the
+// currency. This does not check validity of the provided values.
+func AreEquals(l, r pb.Money) bool {
+	return l.GetCurrencyCode() == r.GetCurrencyCode() &&
+		l.GetUnits() == r.GetUnits() && l.GetNanos() == r.GetNanos()
+}
+
+// Negate returns the same amount with the sign negated.
+func Negate(m pb.Money) pb.Money {
+	return pb.Money{
+		Units:        -m.GetUnits(),
+		Nanos:        -m.GetNanos(),
+		CurrencyCode: m.GetCurrencyCode()}
+}
+
+// Must panics if the given error is not nil. This can be used with other
+// functions like: "m := Must(Sum(a,b))".
+func Must(v pb.Money, err error) pb.Money {
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Sum adds two values. Returns an error if one of the values are invalid or
+// currency codes are not matching (unless currency code is unspecified for
+// both).
+func Sum(l, r pb.Money) (pb.Money, error) {
+	if !IsValid(l) || !IsValid(r) {
+		return pb.Money{}, ErrInvalidValue
+	} else if l.GetCurrencyCode() != r.GetCurrencyCode() {
+		return pb.Money{}, ErrMismatchingCurrency
+	}
+	units := l.GetUnits() + r.GetUnits()
+	nanos := l.GetNanos() + r.GetNanos()
+
+	if (units == 0 && nanos == 0) || (units > 0 && nanos >= 0) || (units < 0 && nanos <= 0) {
+		// same sign <units, nanos>
+		units += int64(nanos / nanosMod)
+		nanos = nanos % nanosMod
+	} else {
+		// different sign. nanos guaranteed to not to go over the limit
+		if units > 0 {
+			units--
+			nanos += nanosMod
+		} else {
+			units++
+			nanos -= nanosMod
+		}
+	}
+
+	return pb.Money{
+		Units:        units,
+		Nanos:        nanos,
+		CurrencyCode: l.GetCurrencyCode()}, nil
+}
+
+// MultiplySlow is a slow multiplication operation done through adding the value
+// to itself n-1 times.
+func MultiplySlow(m pb.Money, n uint32) pb.Money {
+	out := m
+	for n > 1 {
+		out = Must(Sum(out, m))
+		n--
+	}
+	return out
+}

benchmark/boutique/scheduling/110/code/frontend/packaging_info.go

@@ -0,0 +1,79 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+)
+
+/*
+As part of an optional Google Cloud demo, you can run an additional "packaging" microservice (HTTP server).
+This file contains code related to the frontend and the "packaging" microservice.
+*/
+
+var (
+	packagingServiceUrl string
+)
+
+type PackagingInfo struct {
+	Weight float32 `json:"weight"`
+	Width  float32 `json:"width"`
+	Height float32 `json:"height"`
+	Depth  float32 `json:"depth"`
+}
+
+// init() is a special function in Golang that will run when this package is imported.
+func init() {
+	packagingServiceUrl = os.Getenv("PACKAGING_SERVICE_URL")
+}
+
+func isPackagingServiceConfigured() bool {
+	return packagingServiceUrl != ""
+}
+
+func httpGetPackagingInfo(productId string) (*PackagingInfo, error) {
+	// Make the GET request
+	url := packagingServiceUrl + "/" + productId
+	fmt.Println("Requesting packaging info from URL: ", url)
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	// Check the response status code
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("Unexpected status code: %d", resp.StatusCode)
+	}
+
+	// Read the JSON response body
+	responseBody, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	// Decode the JSON response into a PackagingInfo struct
+	var packagingInfo PackagingInfo
+	err = json.Unmarshal(responseBody, &packagingInfo)
+	if err != nil {
+		return nil, err
+	}
+
+	return &packagingInfo, nil
+}

benchmark/boutique/scheduling/110/code/frontend/rpc.go

@@ -0,0 +1,127 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"time"
+
+	pb "github.com/GoogleCloudPlatform/microservices-demo/src/frontend/genproto"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	avoidNoopCurrencyConversionRPC = false
+)
+
+func (fe *frontendServer) getCurrencies(ctx context.Context) ([]string, error) {
+	currs, err := pb.NewCurrencyServiceClient(fe.currencySvcConn).
+		GetSupportedCurrencies(ctx, &pb.Empty{})
+	if err != nil {
+		return nil, err
+	}
+	var out []string
+	for _, c := range currs.CurrencyCodes {
+		if _, ok := whitelistedCurrencies[c]; ok {
+			out = append(out, c)
+		}
+	}
+	return out, nil
+}
+
+func (fe *frontendServer) getProducts(ctx context.Context) ([]*pb.Product, error) {
+	resp, err := pb.NewProductCatalogServiceClient(fe.productCatalogSvcConn).
+		ListProducts(ctx, &pb.Empty{})
+	return resp.GetProducts(), err
+}
+
+func (fe *frontendServer) getProduct(ctx context.Context, id string) (*pb.Product, error) {
+	resp, err := pb.NewProductCatalogServiceClient(fe.productCatalogSvcConn).
+		GetProduct(ctx, &pb.GetProductRequest{Id: id})
+	return resp, err
+}
+
+func (fe *frontendServer) getCart(ctx context.Context, userID string) ([]*pb.CartItem, error) {
+	resp, err := pb.NewCartServiceClient(fe.cartSvcConn).GetCart(ctx, &pb.GetCartRequest{UserId: userID})
+	return resp.GetItems(), err
+}
+
+func (fe *frontendServer) emptyCart(ctx context.Context, userID string) error {
+	_, err := pb.NewCartServiceClient(fe.cartSvcConn).EmptyCart(ctx, &pb.EmptyCartRequest{UserId: userID})
+	return err
+}
+
+func (fe *frontendServer) insertCart(ctx context.Context, userID, productID string, quantity int32) error {
+	_, err := pb.NewCartServiceClient(fe.cartSvcConn).AddItem(ctx, &pb.AddItemRequest{
+		UserId: userID,
+		Item: &pb.CartItem{
+			ProductId: productID,
+			Quantity:  quantity},
+	})
+	return err
+}
+
+func (fe *frontendServer) convertCurrency(ctx context.Context, money *pb.Money, currency string) (*pb.Money, error) {
+	if avoidNoopCurrencyConversionRPC && money.GetCurrencyCode() == currency {
+		return money, nil
+	}
+	return pb.NewCurrencyServiceClient(fe.currencySvcConn).
+		Convert(ctx, &pb.CurrencyConversionRequest{
+			From:   money,
+			ToCode: currency})
+}
+
+func (fe *frontendServer) getShippingQuote(ctx context.Context, items []*pb.CartItem, currency string) (*pb.Money, error) {
+	quote, err := pb.NewShippingServiceClient(fe.shippingSvcConn).GetQuote(ctx,
+		&pb.GetQuoteRequest{
+			Address: nil,
+			Items:   items})
+	if err != nil {
+		return nil, err
+	}
+	localized, err := fe.convertCurrency(ctx, quote.GetCostUsd(), currency)
+	return localized, errors.Wrap(err, "failed to convert currency for shipping cost")
+}
+
+func (fe *frontendServer) getRecommendations(ctx context.Context, userID string, productIDs []string) ([]*pb.Product, error) {
+	resp, err := pb.NewRecommendationServiceClient(fe.recommendationSvcConn).ListRecommendations(ctx,
+		&pb.ListRecommendationsRequest{UserId: userID, ProductIds: productIDs})
+	if err != nil {
+		return nil, err
+	}
+	out := make([]*pb.Product, len(resp.GetProductIds()))
+	for i, v := range resp.GetProductIds() {
+		p, err := fe.getProduct(ctx, v)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to get recommended product info (#%s)", v)
+		}
+		out[i] = p
+	}
+	if len(out) > 4 {
+		out = out[:4] // take only first four to fit the UI
+	}
+	return out, err
+}
+
+func (fe *frontendServer) getAd(ctx context.Context, ctxKeys []string) ([]*pb.Ad, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Millisecond*100)
+	defer cancel()
+
+	resp, err := pb.NewAdServiceClient(fe.adSvcConn).GetAds(ctx, &pb.AdRequest{
+		ContextKeys: ctxKeys,
+	})
+	return resp.GetAds(), errors.Wrap(err, "failed to get ads")
+}

benchmark/boutique/scheduling/110/code/frontend/validator/validator.go

@@ -0,0 +1,83 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validator
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/go-playground/validator/v10"
+)
+
+var validate *validator.Validate
+
+// init() is a special function that will run when this package is imported.
+// It instantiates a SINGLE instance of *validator.Validate with the added
+// benefit of caching struct info and validations.
+func init() {
+	validate = validator.New(validator.WithRequiredStructEnabled())
+}
+
+type Payload interface {
+	Validate() error
+}
+
+type AddToCartPayload struct {
+	Quantity  uint64 `validate:"required,gte=1,lte=10"`
+	ProductID string `validate:"required"`
+}
+
+type PlaceOrderPayload struct {
+	Email         string `validate:"required,email"`
+	StreetAddress string `validate:"required,max=512"`
+	ZipCode       int64  `validate:"required"`
+	City          string `validate:"required,max=128"`
+	State         string `validate:"required,max=128"`
+	Country       string `validate:"required,max=128"`
+	CcNumber      string `validate:"required,credit_card"`
+	CcMonth       int64  `validate:"required,gte=1,lte=12"`
+	CcYear        int64  `validate:"required"`
+	CcCVV         int64  `validate:"required"`
+}
+
+type SetCurrencyPayload struct {
+	Currency string `validate:"required,iso4217"`
+}
+
+// Implementations of the 'Payload' interface.
+func (ad *AddToCartPayload) Validate() error {
+	return validate.Struct(ad)
+}
+
+func (po *PlaceOrderPayload) Validate() error {
+	return validate.Struct(po)
+}
+
+func (sc *SetCurrencyPayload) Validate() error {
+	return validate.Struct(sc)
+}
+
+// Reusable error response function.
+func ValidationErrorResponse(err error) error {
+	validationErrs, ok := err.(validator.ValidationErrors)
+	if !ok {
+		return errors.New("invalid validation error format")
+	}
+	var msg string
+	for _, err := range validationErrs {
+		msg += fmt.Sprintf("Field '%s' is invalid: %s\n", err.Field(), err.Tag())
+	}
+	return fmt.Errorf("%s", msg)
+}

benchmark/boutique/scheduling/110/code/paymentservice/charge.js

@@ -0,0 +1,86 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const cardValidator = require('simple-card-validator');
+const { v4: uuidv4 } = require('uuid');
+const pino = require('pino');
+
+const logger = pino({
+  name: 'paymentservice-charge',
+  messageKey: 'message',
+  formatters: {
+    level (logLevelString, logLevelNum) {
+      return { severity: logLevelString }
+    }
+  }
+});
+
+
+class CreditCardError extends Error {
+  constructor (message) {
+    super(message);
+    this.code = 400; // Invalid argument error
+  }
+}
+
+class InvalidCreditCard extends CreditCardError {
+  constructor (cardType) {
+    super(`Credit card info is invalid`);
+  }
+}
+
+class UnacceptedCreditCard extends CreditCardError {
+  constructor (cardType) {
+    super(`Sorry, we cannot process ${cardType} credit cards. Only VISA or MasterCard is accepted.`);
+  }
+}
+
+class ExpiredCreditCard extends CreditCardError {
+  constructor (number, month, year) {
+    super(`Your credit card (ending ${number.substr(-4)}) expired on ${month}/${year}`);
+  }
+}
+
+/**
+ * Verifies the credit card number and (pretend) charges the card.
+ *
+ * @param {*} request
+ * @return transaction_id - a random uuid.
+ */
+module.exports = function charge (request) {
+  const { amount, credit_card: creditCard } = request;
+  const cardNumber = creditCard.credit_card_number;
+  const cardInfo = cardValidator(cardNumber);
+  const {
+    card_type: cardType,
+    valid
+  } = cardInfo.getCardDetails();
+
+  if (!valid) { throw new InvalidCreditCard(); }
+
+  // Only VISA and mastercard is accepted, other card types (AMEX, dinersclub) will
+  // throw UnacceptedCreditCard error.
+  if (!(cardType === 'visa' || cardType === 'mastercard')) { throw new UnacceptedCreditCard(cardType); }
+
+  // Also validate expiration is > today.
+  const currentMonth = new Date().getMonth() + 1;
+  const currentYear = new Date().getFullYear();
+  const { credit_card_expiration_year: year, credit_card_expiration_month: month } = creditCard;
+  if ((currentYear * 12 + currentMonth) > (year * 12 + month)) { throw new ExpiredCreditCard(cardNumber.replace('-', ''), month, year); }
+
+  logger.info(`Transaction processed: ${cardType} ending ${cardNumber.substr(-4)} \
+    Amount: ${amount.currency_code}${amount.units}.${amount.nanos}`);
+
+  return { transaction_id: uuidv4() };
+};

benchmark/boutique/scheduling/110/code/paymentservice/index.js

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const logger = require('./logger')
+
+if (process.env.DISABLE_PROFILER) {
+  logger.info("Profiler disabled.")
+} else {
+  logger.info("Profiler enabled.")
+  require('@google-cloud/profiler').start({
+    serviceContext: {
+      service: 'paymentservice',
+      version: '1.0.0'
+    }
+  });
+}
+
+
+if (process.env.ENABLE_TRACING == "1") {
+  logger.info("Tracing enabled.")
+
+  const { resourceFromAttributes } = require('@opentelemetry/resources');
+
+  const { ATTR_SERVICE_NAME }= require('@opentelemetry/semantic-conventions');
+
+  const { GrpcInstrumentation } = require('@opentelemetry/instrumentation-grpc');
+  const { registerInstrumentations } = require('@opentelemetry/instrumentation');
+  const opentelemetry = require('@opentelemetry/sdk-node');
+
+  const { OTLPTraceExporter } = require('@opentelemetry/exporter-otlp-grpc');
+
+  const collectorUrl = process.env.COLLECTOR_SERVICE_ADDR;
+  const traceExporter = new OTLPTraceExporter({url: collectorUrl});
+
+  const sdk = new opentelemetry.NodeSDK({
+    resource: resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || 'paymentservice',
+    }),
+    traceExporter: traceExporter,
+  });
+
+  registerInstrumentations({
+    instrumentations: [new GrpcInstrumentation()]
+  });
+
+  sdk.start()
+} else {
+  logger.info("Tracing disabled.")
+}
+
+
+const path = require('path');
+const HipsterShopServer = require('./server');
+
+const PORT = process.env['PORT'];
+const PROTO_PATH = path.join(__dirname, '/proto/');
+
+const server = new HipsterShopServer(PROTO_PATH, PORT);
+
+server.listen();

benchmark/boutique/scheduling/110/code/paymentservice/logger.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const pino = require('pino');
+
+module.exports = pino({
+  name: 'paymentservice-server',
+  messageKey: 'message',
+  formatters: {
+    level (logLevelString, logLevelNum) {
+      return { severity: logLevelString }
+    }
+  }
+});

benchmark/boutique/scheduling/110/code/paymentservice/server.js

@@ -0,0 +1,106 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const path = require('path');
+const grpc = require('@grpc/grpc-js');
+const protoLoader = require('@grpc/proto-loader');
+
+const charge = require('./charge');
+
+const logger = require('./logger')
+
+class HipsterShopServer {
+  constructor(protoRoot, port = HipsterShopServer.PORT) {
+    this.port = port;
+
+    this.packages = {
+      hipsterShop: this.loadProto(path.join(protoRoot, 'demo.proto')),
+      health: this.loadProto(path.join(protoRoot, 'grpc/health/v1/health.proto'))
+    };
+
+    this.server = new grpc.Server();
+    this.loadAllProtos(protoRoot);
+  }
+
+  /**
+   * Handler for PaymentService.Charge.
+   * @param {*} call  { ChargeRequest }
+   * @param {*} callback  fn(err, ChargeResponse)
+   */
+  static ChargeServiceHandler(call, callback) {
+    try {
+      logger.info(`PaymentService#Charge invoked with request ${JSON.stringify(call.request)}`);
+      const response = charge(call.request);
+      callback(null, response);
+    } catch (err) {
+      console.warn(err);
+      callback(err);
+    }
+  }
+
+  static CheckHandler(call, callback) {
+    callback(null, { status: 'SERVING' });
+  }
+
+
+  listen() {
+    const server = this.server 
+    const port = this.port
+    server.bindAsync(
+      `[::]:${port}`,
+      grpc.ServerCredentials.createInsecure(),
+      function () {
+        logger.info(`PaymentService gRPC server started on port ${port}`);
+        server.start();
+      }
+    );
+  }
+
+  loadProto(path) {
+    const packageDefinition = protoLoader.loadSync(
+      path,
+      {
+        keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true
+      }
+    );
+    return grpc.loadPackageDefinition(packageDefinition);
+  }
+
+  loadAllProtos(protoRoot) {
+    const hipsterShopPackage = this.packages.hipsterShop.hipstershop;
+    const healthPackage = this.packages.health.grpc.health.v1;
+
+    this.server.addService(
+      hipsterShopPackage.PaymentService.service,
+      {
+        charge: HipsterShopServer.ChargeServiceHandler.bind(this)
+      }
+    );
+
+    this.server.addService(
+      healthPackage.Health.service,
+      {
+        check: HipsterShopServer.CheckHandler.bind(this)
+      }
+    );
+  }
+}
+
+HipsterShopServer.PORT = process.env.PORT;
+
+module.exports = HipsterShopServer;

benchmark/boutique/scheduling/110/code/productcatalogservice/catalog_loader.go

@@ -0,0 +1,161 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net"
+	"os"
+	"strings"
+
+	"cloud.google.com/go/alloydbconn"
+	secretmanager "cloud.google.com/go/secretmanager/apiv1"
+	"cloud.google.com/go/secretmanager/apiv1/secretmanagerpb"
+	pb "github.com/GoogleCloudPlatform/microservices-demo/src/productcatalogservice/genproto"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func loadCatalog(catalog *pb.ListProductsResponse) error {
+	catalogMutex.Lock()
+	defer catalogMutex.Unlock()
+
+	if os.Getenv("ALLOYDB_CLUSTER_NAME") != "" {
+		return loadCatalogFromAlloyDB(catalog)
+	}
+
+	return loadCatalogFromLocalFile(catalog)
+}
+
+func loadCatalogFromLocalFile(catalog *pb.ListProductsResponse) error {
+	log.Info("loading catalog from local products.json file...")
+
+	catalogJSON, err := os.ReadFile("products.json")
+	if err != nil {
+		log.Warnf("failed to open product catalog json file: %v", err)
+		return err
+	}
+
+	if err := jsonpb.Unmarshal(bytes.NewReader(catalogJSON), catalog); err != nil {
+		log.Warnf("failed to parse the catalog JSON: %v", err)
+		return err
+	}
+
+	log.Info("successfully parsed product catalog json")
+	return nil
+}
+
+func getSecretPayload(project, secret, version string) (string, error) {
+	ctx := context.Background()
+	client, err := secretmanager.NewClient(ctx)
+	if err != nil {
+		log.Warnf("failed to create SecretManager client: %v", err)
+		return "", err
+	}
+	defer client.Close()
+
+	req := &secretmanagerpb.AccessSecretVersionRequest{
+		Name: fmt.Sprintf("projects/%s/secrets/%s/versions/%s", project, secret, version),
+	}
+
+	// Call the API.
+	result, err := client.AccessSecretVersion(ctx, req)
+	if err != nil {
+		log.Warnf("failed to access SecretVersion: %v", err)
+		return "", err
+	}
+
+	return string(result.Payload.Data), nil
+}
+
+func loadCatalogFromAlloyDB(catalog *pb.ListProductsResponse) error {
+	log.Info("loading catalog from AlloyDB...")
+
+	projectID := os.Getenv("PROJECT_ID")
+	region := os.Getenv("REGION")
+	pgClusterName := os.Getenv("ALLOYDB_CLUSTER_NAME")
+	pgInstanceName := os.Getenv("ALLOYDB_INSTANCE_NAME")
+	pgDatabaseName := os.Getenv("ALLOYDB_DATABASE_NAME")
+	pgTableName := os.Getenv("ALLOYDB_TABLE_NAME")
+	pgSecretName := os.Getenv("ALLOYDB_SECRET_NAME")
+
+	pgPassword, err := getSecretPayload(projectID, pgSecretName, "latest")
+	if err != nil {
+		return err
+	}
+
+	dialer, err := alloydbconn.NewDialer(context.Background())
+	if err != nil {
+		log.Warnf("failed to set-up dialer connection: %v", err)
+		return err
+	}
+	cleanup := func() error { return dialer.Close() }
+	defer cleanup()
+
+	dsn := fmt.Sprintf(
+		"user=%s password=%s dbname=%s sslmode=disable",
+		"postgres", pgPassword, pgDatabaseName,
+	)
+
+	config, err := pgxpool.ParseConfig(dsn)
+	if err != nil {
+		log.Warnf("failed to parse DSN config: %v", err)
+		return err
+	}
+
+	pgInstanceURI := fmt.Sprintf("projects/%s/locations/%s/clusters/%s/instances/%s", projectID, region, pgClusterName, pgInstanceName)
+	config.ConnConfig.DialFunc = func(ctx context.Context, _ string, _ string) (net.Conn, error) {
+		return dialer.Dial(ctx, pgInstanceURI)
+	}
+
+	pool, err := pgxpool.NewWithConfig(context.Background(), config)
+	if err != nil {
+		log.Warnf("failed to set-up pgx pool: %v", err)
+		return err
+	}
+	defer pool.Close()
+
+	query := "SELECT id, name, description, picture, price_usd_currency_code, price_usd_units, price_usd_nanos, categories FROM " + pgTableName
+	rows, err := pool.Query(context.Background(), query)
+	if err != nil {
+		log.Warnf("failed to query database: %v", err)
+		return err
+	}
+	defer rows.Close()
+
+	catalog.Products = catalog.Products[:0]
+	for rows.Next() {
+		product := &pb.Product{}
+		product.PriceUsd = &pb.Money{}
+
+		var categories string
+		err = rows.Scan(&product.Id, &product.Name, &product.Description,
+			&product.Picture, &product.PriceUsd.CurrencyCode, &product.PriceUsd.Units,
+			&product.PriceUsd.Nanos, &categories)
+		if err != nil {
+			log.Warnf("failed to scan query result row: %v", err)
+			return err
+		}
+		categories = strings.ToLower(categories)
+		product.Categories = strings.Split(categories, ",")
+
+		catalog.Products = append(catalog.Products, product)
+	}
+
+	log.Info("successfully parsed product catalog from AlloyDB")
+	return nil
+}

benchmark/boutique/scheduling/110/code/productcatalogservice/product_catalog.go

@@ -0,0 +1,83 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	pb "github.com/GoogleCloudPlatform/microservices-demo/src/productcatalogservice/genproto"
+	"google.golang.org/grpc/codes"
+	healthpb "google.golang.org/grpc/health/grpc_health_v1"
+	"google.golang.org/grpc/status"
+)
+
+type productCatalog struct {
+	pb.UnimplementedProductCatalogServiceServer
+	catalog pb.ListProductsResponse
+}
+
+func (p *productCatalog) Check(ctx context.Context, req *healthpb.HealthCheckRequest) (*healthpb.HealthCheckResponse, error) {
+	return &healthpb.HealthCheckResponse{Status: healthpb.HealthCheckResponse_SERVING}, nil
+}
+
+func (p *productCatalog) Watch(req *healthpb.HealthCheckRequest, ws healthpb.Health_WatchServer) error {
+	return status.Errorf(codes.Unimplemented, "health check via Watch not implemented")
+}
+
+func (p *productCatalog) ListProducts(context.Context, *pb.Empty) (*pb.ListProductsResponse, error) {
+	time.Sleep(extraLatency)
+
+	return &pb.ListProductsResponse{Products: p.parseCatalog()}, nil
+}
+
+func (p *productCatalog) GetProduct(ctx context.Context, req *pb.GetProductRequest) (*pb.Product, error) {
+	time.Sleep(extraLatency)
+
+	catalog := p.parseCatalog()
+	for _, product := range catalog {
+		if req.Id == product.Id {
+			return product, nil
+		}
+	}
+
+	return nil, status.Errorf(codes.NotFound, "no product with ID %s", req.Id)
+}
+
+func (p *productCatalog) SearchProducts(ctx context.Context, req *pb.SearchProductsRequest) (*pb.SearchProductsResponse, error) {
+	time.Sleep(extraLatency)
+
+	var ps []*pb.Product
+	for _, product := range p.parseCatalog() {
+		if strings.Contains(strings.ToLower(product.Name), strings.ToLower(req.Query)) ||
+			strings.Contains(strings.ToLower(product.Description), strings.ToLower(req.Query)) {
+			ps = append(ps, product)
+		}
+	}
+
+	return &pb.SearchProductsResponse{Results: ps}, nil
+}
+
+func (p *productCatalog) parseCatalog() []*pb.Product {
+	if reloadCatalog || len(p.catalog.Products) == 0 {
+		err := loadCatalog(&p.catalog)
+		if err != nil {
+			return []*pb.Product{}
+		}
+	}
+
+	return p.catalog.Products
+}

benchmark/boutique/scheduling/110/code/productcatalogservice/server.go

@@ -0,0 +1,217 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"net"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	pb "github.com/GoogleCloudPlatform/microservices-demo/src/productcatalogservice/genproto"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/health"
+	healthpb "google.golang.org/grpc/health/grpc_health_v1"
+
+	"cloud.google.com/go/profiler"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/propagation"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	"google.golang.org/grpc"
+)
+
+var (
+	catalogMutex *sync.Mutex
+	log          *logrus.Logger
+	extraLatency time.Duration
+
+	port = "3550"
+
+	reloadCatalog bool
+)
+
+func init() {
+	log = logrus.New()
+	log.Formatter = &logrus.JSONFormatter{
+		FieldMap: logrus.FieldMap{
+			logrus.FieldKeyTime:  "timestamp",
+			logrus.FieldKeyLevel: "severity",
+			logrus.FieldKeyMsg:   "message",
+		},
+		TimestampFormat: time.RFC3339Nano,
+	}
+	log.Out = os.Stdout
+	catalogMutex = &sync.Mutex{}
+}
+
+func main() {
+	if os.Getenv("ENABLE_TRACING") == "1" {
+		err := initTracing()
+		if err != nil {
+			log.Warnf("warn: failed to start tracer: %+v", err)
+		}
+	} else {
+		log.Info("Tracing disabled.")
+	}
+
+	if os.Getenv("DISABLE_PROFILER") == "" {
+		log.Info("Profiling enabled.")
+		go initProfiling("productcatalogservice", "1.0.0")
+	} else {
+		log.Info("Profiling disabled.")
+	}
+
+	flag.Parse()
+
+	// set injected latency
+	if s := os.Getenv("EXTRA_LATENCY"); s != "" {
+		v, err := time.ParseDuration(s)
+		if err != nil {
+			log.Fatalf("failed to parse EXTRA_LATENCY (%s) as time.Duration: %+v", v, err)
+		}
+		extraLatency = v
+		log.Infof("extra latency enabled (duration: %v)", extraLatency)
+	} else {
+		extraLatency = time.Duration(0)
+	}
+
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGUSR1, syscall.SIGUSR2)
+	go func() {
+		for {
+			sig := <-sigs
+			log.Printf("Received signal: %s", sig)
+			if sig == syscall.SIGUSR1 {
+				reloadCatalog = true
+				log.Infof("Enable catalog reloading")
+			} else {
+				reloadCatalog = false
+				log.Infof("Disable catalog reloading")
+			}
+		}
+	}()
+
+	if os.Getenv("PORT") != "" {
+		port = os.Getenv("PORT")
+	}
+	log.Infof("starting grpc server at :%s", port)
+	run(port)
+	select {}
+}
+
+func run(port string) string {
+	listener, err := net.Listen("tcp", fmt.Sprintf(":%s", port))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Propagate trace context
+	otel.SetTextMapPropagator(
+		propagation.NewCompositeTextMapPropagator(
+			propagation.TraceContext{}, propagation.Baggage{}))
+	var srv *grpc.Server
+	srv = grpc.NewServer(
+		grpc.StatsHandler(otelgrpc.NewServerHandler()))
+
+	svc := &productCatalog{}
+	err = loadCatalog(&svc.catalog)
+	if err != nil {
+		log.Fatalf("could not parse product catalog: %v", err)
+	}
+
+	pb.RegisterProductCatalogServiceServer(srv, svc)
+	healthcheck := health.NewServer()
+	healthpb.RegisterHealthServer(srv, healthcheck)
+	go srv.Serve(listener)
+
+	return listener.Addr().String()
+}
+
+func initStats() {
+	// TODO(drewbr) Implement OpenTelemetry stats
+}
+
+func initTracing() error {
+	var (
+		collectorAddr string
+		collectorConn *grpc.ClientConn
+	)
+
+	ctx := context.Background()
+
+	mustMapEnv(&collectorAddr, "COLLECTOR_SERVICE_ADDR")
+	mustConnGRPC(ctx, &collectorConn, collectorAddr)
+
+	exporter, err := otlptracegrpc.New(
+		ctx,
+		otlptracegrpc.WithGRPCConn(collectorConn))
+	if err != nil {
+		log.Warnf("warn: Failed to create trace exporter: %v", err)
+	}
+	tp := sdktrace.NewTracerProvider(
+		sdktrace.WithBatcher(exporter),
+		sdktrace.WithSampler(sdktrace.AlwaysSample()))
+	otel.SetTracerProvider(tp)
+	return err
+}
+
+func initProfiling(service, version string) {
+	for i := 1; i <= 3; i++ {
+		if err := profiler.Start(profiler.Config{
+			Service:        service,
+			ServiceVersion: version,
+			// ProjectID must be set if not running on GCP.
+			// ProjectID: "my-project",
+		}); err != nil {
+			log.Warnf("failed to start profiler: %+v", err)
+		} else {
+			log.Info("started Stackdriver profiler")
+			return
+		}
+		d := time.Second * 10 * time.Duration(i)
+		log.Infof("sleeping %v to retry initializing Stackdriver profiler", d)
+		time.Sleep(d)
+	}
+	log.Warn("could not initialize Stackdriver profiler after retrying, giving up")
+}
+
+func mustMapEnv(target *string, envKey string) {
+	v := os.Getenv(envKey)
+	if v == "" {
+		panic(fmt.Sprintf("environment variable %q not set", envKey))
+	}
+	*target = v
+}
+
+func mustConnGRPC(ctx context.Context, conn **grpc.ClientConn, addr string) {
+	var err error
+	_, cancel := context.WithTimeout(ctx, time.Second*3)
+	defer cancel()
+	*conn, err = grpc.NewClient(addr,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithStatsHandler(otelgrpc.NewClientHandler()))
+	if err != nil {
+		panic(errors.Wrapf(err, "grpc: failed to connect %s", addr))
+	}
+}

benchmark/boutique/scheduling/110/code/recommendationservice/client.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python
+#
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+import grpc
+import demo_pb2
+import demo_pb2_grpc
+
+from logger import getJSONLogger
+logger = getJSONLogger('recommendationservice-server')
+
+if __name__ == "__main__":
+    # get port
+    if len(sys.argv) > 1:
+        port = sys.argv[1]
+    else:
+        port = "8080"
+
+    # set up server stub
+    channel = grpc.insecure_channel('localhost:'+port)
+    stub = demo_pb2_grpc.RecommendationServiceStub(channel)
+    # form request
+    request = demo_pb2.ListRecommendationsRequest(user_id="test", product_ids=["test"])
+    # make call to server
+    response = stub.ListRecommendations(request)
+    logger.info(response)

benchmark/boutique/scheduling/110/code/recommendationservice/logger.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python
+#
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import sys
+from pythonjsonlogger import jsonlogger
+
+# TODO(yoshifumi) this class is duplicated since other Python services are
+# not sharing the modules for logging.
+class CustomJsonFormatter(jsonlogger.JsonFormatter):
+  def add_fields(self, log_record, record, message_dict):
+    super(CustomJsonFormatter, self).add_fields(log_record, record, message_dict)
+    if not log_record.get('timestamp'):
+      log_record['timestamp'] = record.created
+    if log_record.get('severity'):
+      log_record['severity'] = log_record['severity'].upper()
+    else:
+      log_record['severity'] = record.levelname
+
+def getJSONLogger(name):
+  logger = logging.getLogger(name)
+  handler = logging.StreamHandler(sys.stdout)
+  formatter = CustomJsonFormatter('%(timestamp)s %(severity)s %(name)s %(message)s')
+  handler.setFormatter(formatter)
+  logger.addHandler(handler)
+  logger.setLevel(logging.INFO)
+  logger.propagate = False
+  return logger

benchmark/boutique/scheduling/110/code/recommendationservice/recommendation_server.py

@@ -0,0 +1,156 @@
+#!/usr/bin/python
+#
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import random
+import time
+import traceback
+from concurrent import futures
+
+# @TODO: Temporarily removed in https://github.com/GoogleCloudPlatform/microservices-demo/pull/3196
+# import googlecloudprofiler
+
+from google.auth.exceptions import DefaultCredentialsError
+import grpc
+
+import demo_pb2
+import demo_pb2_grpc
+from grpc_health.v1 import health_pb2
+from grpc_health.v1 import health_pb2_grpc
+
+from opentelemetry import trace
+from opentelemetry.instrumentation.grpc import GrpcInstrumentorClient, GrpcInstrumentorServer
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+
+from logger import getJSONLogger
+logger = getJSONLogger('recommendationservice-server')
+
+def initStackdriverProfiling():
+  project_id = None
+  try:
+    project_id = os.environ["GCP_PROJECT_ID"]
+  except KeyError:
+    # Environment variable not set
+    pass
+
+  # @TODO: Temporarily removed in https://github.com/GoogleCloudPlatform/microservices-demo/pull/3196
+  # for retry in range(1,4):
+  #   try:
+  #     if project_id:
+  #       googlecloudprofiler.start(service='recommendation_server', service_version='1.0.0', verbose=0, project_id=project_id)
+  #     else:
+  #       googlecloudprofiler.start(service='recommendation_server', service_version='1.0.0', verbose=0)
+  #     logger.info("Successfully started Stackdriver Profiler.")
+  #     return
+  #   except (BaseException) as exc:
+  #     logger.info("Unable to start Stackdriver Profiler Python agent. " + str(exc))
+  #     if (retry < 4):
+  #       logger.info("Sleeping %d seconds to retry Stackdriver Profiler agent initialization"%(retry*10))
+  #       time.sleep (1)
+  #     else:
+  #       logger.warning("Could not initialize Stackdriver Profiler after retrying, giving up")
+  return
+
+class RecommendationService(demo_pb2_grpc.RecommendationServiceServicer):
+    def ListRecommendations(self, request, context):
+        max_responses = 5
+        # fetch list of products from product catalog stub
+        cat_response = product_catalog_stub.ListProducts(demo_pb2.Empty())
+        product_ids = [x.id for x in cat_response.products]
+        filtered_products = list(set(product_ids)-set(request.product_ids))
+        num_products = len(filtered_products)
+        num_return = min(max_responses, num_products)
+        # sample list of indicies to return
+        indices = random.sample(range(num_products), num_return)
+        # fetch product ids from indices
+        prod_list = [filtered_products[i] for i in indices]
+        logger.info("[Recv ListRecommendations] product_ids={}".format(prod_list))
+        # build and return response
+        response = demo_pb2.ListRecommendationsResponse()
+        response.product_ids.extend(prod_list)
+        return response
+
+    def Check(self, request, context):
+        return health_pb2.HealthCheckResponse(
+            status=health_pb2.HealthCheckResponse.SERVING)
+
+    def Watch(self, request, context):
+        return health_pb2.HealthCheckResponse(
+            status=health_pb2.HealthCheckResponse.UNIMPLEMENTED)
+
+
+if __name__ == "__main__":
+    logger.info("initializing recommendationservice")
+
+    try:
+      if "DISABLE_PROFILER" in os.environ:
+        raise KeyError()
+      else:
+        logger.info("Profiler enabled.")
+        initStackdriverProfiling()
+    except KeyError:
+        logger.info("Profiler disabled.")
+
+    try:
+      grpc_client_instrumentor = GrpcInstrumentorClient()
+      grpc_client_instrumentor.instrument()
+      grpc_server_instrumentor = GrpcInstrumentorServer()
+      grpc_server_instrumentor.instrument()
+      if os.environ["ENABLE_TRACING"] == "1":
+        trace.set_tracer_provider(TracerProvider())
+        otel_endpoint = os.getenv("COLLECTOR_SERVICE_ADDR", "localhost:4317")
+        trace.get_tracer_provider().add_span_processor(
+          BatchSpanProcessor(
+              OTLPSpanExporter(
+              endpoint = otel_endpoint,
+              insecure = True
+            )
+          )
+        )
+    except (KeyError, DefaultCredentialsError):
+        logger.info("Tracing disabled.")
+    except Exception as e:
+        logger.warn(f"Exception on Cloud Trace setup: {traceback.format_exc()}, tracing disabled.") 
+
+    port = os.environ.get('PORT', "8080")
+    catalog_addr = os.environ.get('PRODUCT_CATALOG_SERVICE_ADDR', '')
+    if catalog_addr == "":
+        raise Exception('PRODUCT_CATALOG_SERVICE_ADDR environment variable not set')
+    logger.info("product catalog address: " + catalog_addr)
+    channel = grpc.insecure_channel(catalog_addr)
+    product_catalog_stub = demo_pb2_grpc.ProductCatalogServiceStub(channel)
+
+    # create gRPC server
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+
+    # add class to gRPC server
+    service = RecommendationService()
+    demo_pb2_grpc.add_RecommendationServiceServicer_to_server(service, server)
+    health_pb2_grpc.add_HealthServicer_to_server(service, server)
+
+    # start server
+    logger.info("listening on port: " + port)
+    server.add_insecure_port('[::]:'+port)
+    server.start()
+
+    # keep alive
+    try:
+         while True:
+            time.sleep(10000)
+    except KeyboardInterrupt:
+            server.stop(0)

benchmark/boutique/scheduling/110/code/shippingservice/main.go

@@ -0,0 +1,183 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"time"
+
+	"cloud.google.com/go/profiler"
+	"github.com/sirupsen/logrus"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/health"
+	"google.golang.org/grpc/reflection"
+	"google.golang.org/grpc/status"
+
+	pb "github.com/GoogleCloudPlatform/microservices-demo/src/shippingservice/genproto"
+	healthpb "google.golang.org/grpc/health/grpc_health_v1"
+)
+
+const (
+	defaultPort = "50051"
+)
+
+var log *logrus.Logger
+
+func init() {
+	log = logrus.New()
+	log.Level = logrus.DebugLevel
+	log.Formatter = &logrus.JSONFormatter{
+		FieldMap: logrus.FieldMap{
+			logrus.FieldKeyTime:  "timestamp",
+			logrus.FieldKeyLevel: "severity",
+			logrus.FieldKeyMsg:   "message",
+		},
+		TimestampFormat: time.RFC3339Nano,
+	}
+	log.Out = os.Stdout
+}
+
+func main() {
+	if os.Getenv("DISABLE_TRACING") == "" {
+		log.Info("Tracing enabled, but temporarily unavailable")
+		log.Info("See https://github.com/GoogleCloudPlatform/microservices-demo/issues/422 for more info.")
+		go initTracing()
+	} else {
+		log.Info("Tracing disabled.")
+	}
+
+	if os.Getenv("DISABLE_PROFILER") == "" {
+		log.Info("Profiling enabled.")
+		go initProfiling("shippingservice", "1.0.0")
+	} else {
+		log.Info("Profiling disabled.")
+	}
+
+	port := defaultPort
+	if value, ok := os.LookupEnv("PORT"); ok {
+		port = value
+	}
+	port = fmt.Sprintf(":%s", port)
+
+	lis, err := net.Listen("tcp", port)
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+
+	var srv *grpc.Server
+	if os.Getenv("DISABLE_STATS") == "" {
+		log.Info("Stats enabled, but temporarily unavailable")
+		srv = grpc.NewServer()
+	} else {
+		log.Info("Stats disabled.")
+		srv = grpc.NewServer()
+	}
+	svc := &server{}
+	pb.RegisterShippingServiceServer(srv, svc)
+	healthcheck := health.NewServer()
+	healthpb.RegisterHealthServer(srv, healthcheck)
+	log.Infof("Shipping Service listening on port %s", port)
+
+	// Register reflection service on gRPC server.
+	reflection.Register(srv)
+	if err := srv.Serve(lis); err != nil {
+		log.Fatalf("failed to serve: %v", err)
+	}
+}
+
+// server controls RPC service responses.
+type server struct {
+	pb.UnimplementedShippingServiceServer
+}
+
+// Check is for health checking.
+func (s *server) Check(ctx context.Context, req *healthpb.HealthCheckRequest) (*healthpb.HealthCheckResponse, error) {
+	return &healthpb.HealthCheckResponse{Status: healthpb.HealthCheckResponse_SERVING}, nil
+}
+
+func (s *server) Watch(req *healthpb.HealthCheckRequest, ws healthpb.Health_WatchServer) error {
+	return status.Errorf(codes.Unimplemented, "health check via Watch not implemented")
+}
+
+// GetQuote produces a shipping quote (cost) in USD.
+func (s *server) GetQuote(ctx context.Context, in *pb.GetQuoteRequest) (*pb.GetQuoteResponse, error) {
+	log.Info("[GetQuote] received request")
+	defer log.Info("[GetQuote] completed request")
+
+	// 1. Generate a quote based on the total number of items to be shipped.
+	count := 0
+	for _, item := range in.Items {
+		count += int(item.Quantity)
+	}
+	quote := CreateQuoteFromCount(count)
+
+	// 2. Generate a response.
+	return &pb.GetQuoteResponse{
+		CostUsd: &pb.Money{
+			CurrencyCode: "USD",
+			Units:        int64(quote.Dollars),
+			Nanos:        int32(quote.Cents * 10000000)},
+	}, nil
+
+}
+
+// ShipOrder mocks that the requested items will be shipped.
+// It supplies a tracking ID for notional lookup of shipment delivery status.
+func (s *server) ShipOrder(ctx context.Context, in *pb.ShipOrderRequest) (*pb.ShipOrderResponse, error) {
+	log.Info("[ShipOrder] received request")
+	defer log.Info("[ShipOrder] completed request")
+	// 1. Create a Tracking ID
+	baseAddress := fmt.Sprintf("%s, %s, %s", in.Address.StreetAddress, in.Address.City, in.Address.State)
+	id := CreateTrackingId(baseAddress)
+
+	// 2. Generate a response.
+	return &pb.ShipOrderResponse{
+		TrackingId: id,
+	}, nil
+}
+
+func initStats() {
+	//TODO(arbrown) Implement OpenTelemetry stats
+}
+
+func initTracing() {
+	// TODO(arbrown) Implement OpenTelemetry tracing
+}
+
+func initProfiling(service, version string) {
+	// TODO(ahmetb) this method is duplicated in other microservices using Go
+	// since they are not sharing packages.
+	for i := 1; i <= 3; i++ {
+		if err := profiler.Start(profiler.Config{
+			Service:        service,
+			ServiceVersion: version,
+			// ProjectID must be set if not running on GCP.
+			// ProjectID: "my-project",
+		}); err != nil {
+			log.Warnf("failed to start profiler: %+v", err)
+		} else {
+			log.Info("started Stackdriver profiler")
+			return
+		}
+		d := time.Second * 10 * time.Duration(i)
+		log.Infof("sleeping %v to retry initializing Stackdriver profiler", d)
+		time.Sleep(d)
+	}
+	log.Warn("could not initialize Stackdriver profiler after retrying, giving up")
+}

benchmark/boutique/scheduling/110/code/shippingservice/quote.go

@@ -0,0 +1,48 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+// Quote represents a currency value.
+type Quote struct {
+	Dollars uint32
+	Cents   uint32
+}
+
+// String representation of the Quote.
+func (q Quote) String() string {
+	return fmt.Sprintf("$%d.%d", q.Dollars, q.Cents)
+}
+
+// CreateQuoteFromCount takes a number of items and returns a shipping quote.
+func CreateQuoteFromCount(count int) Quote {
+	if count == 0 {
+		return CreateQuoteFromFloat(0)
+	}
+	return CreateQuoteFromFloat(8.99)
+}
+
+// CreateQuoteFromFloat takes a price represented as a float and creates a Price struct.
+func CreateQuoteFromFloat(value float64) Quote {
+	units, fraction := math.Modf(value)
+	return Quote{
+		uint32(units),
+		uint32(math.Trunc(fraction * 100)),
+	}
+}

benchmark/boutique/scheduling/110/code/shippingservice/tracker.go

@@ -0,0 +1,47 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"fmt"
+	"math/rand"
+)
+
+// CreateTrackingId generates a tracking ID.
+func CreateTrackingId(salt string) string {
+	return fmt.Sprintf("%c%c-%d%s-%d%s",
+		getRandomLetterCode(),
+		getRandomLetterCode(),
+		len(salt),
+		getRandomNumber(3),
+		len(salt)/2,
+		getRandomNumber(7),
+	)
+}
+
+// getRandomLetterCode generates a code point value for a capital letter.
+func getRandomLetterCode() uint32 {
+	return 65 + uint32(rand.Intn(25))
+}
+
+// getRandomNumber generates a string representation of a number with the requested number of digits.
+func getRandomNumber(digits int) string {
+	str := ""
+	for i := 0; i < digits; i++ {
+		str = fmt.Sprintf("%s%d", str, rand.Intn(10))
+	}
+
+	return str
+}

benchmark/boutique/scheduling/110/metadata.json

@@ -0,0 +1,10 @@
+{
+  "namespace": "boutique",
+  "query": "Service Availability Disruption.",
+  "difficulty": "easy",
+  "result": {
+    "fault_taxonomy": "Scheduling_Fault",
+    "fault_object": "app/redis-cart",
+    "root_cause": "node_selector_mismatch"
+  }
+}

benchmark/boutique/scheduling/110/raw_data/alert.json

@@ -0,0 +1 @@
+{}

benchmark/boutique/scheduling/111/code/adservice/src/main/java/hipstershop/AdService.java

@@ -0,0 +1,238 @@
+/*
+ * Copyright 2018, Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package hipstershop;
+
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import hipstershop.Demo.Ad;
+import hipstershop.Demo.AdRequest;
+import hipstershop.Demo.AdResponse;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.services.*;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public final class AdService {
+
+  private static final Logger logger = LogManager.getLogger(AdService.class);
+
+  @SuppressWarnings("FieldCanBeLocal")
+  private static int MAX_ADS_TO_SERVE = 2;
+
+  private Server server;
+  private HealthStatusManager healthMgr;
+
+  private static final AdService service = new AdService();
+
+  private void start() throws IOException {
+    int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "9555"));
+    healthMgr = new HealthStatusManager();
+
+    server =
+        ServerBuilder.forPort(port)
+            .addService(new AdServiceImpl())
+            .addService(healthMgr.getHealthService())
+            .build()
+            .start();
+    logger.info("Ad Service started, listening on " + port);
+    Runtime.getRuntime()
+        .addShutdownHook(
+            new Thread(
+                () -> {
+                  // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+                  System.err.println(
+                      "*** shutting down gRPC ads server since JVM is shutting down");
+                  AdService.this.stop();
+                  System.err.println("*** server shut down");
+                }));
+    healthMgr.setStatus("", ServingStatus.SERVING);
+  }
+
+  private void stop() {
+    if (server != null) {
+      healthMgr.clearStatus("");
+      server.shutdown();
+    }
+  }
+
+  private static class AdServiceImpl extends hipstershop.AdServiceGrpc.AdServiceImplBase {
+
+    /**
+     * Retrieves ads based on context provided in the request {@code AdRequest}.
+     *
+     * @param req the request containing context.
+     * @param responseObserver the stream observer which gets notified with the value of {@code
+     *     AdResponse}
+     */
+    @Override
+    public void getAds(AdRequest req, StreamObserver<AdResponse> responseObserver) {
+      AdService service = AdService.getInstance();
+      try {
+        List<Ad> allAds = new ArrayList<>();
+        logger.info("received ad request (context_words=" + req.getContextKeysList() + ")");
+        if (req.getContextKeysCount() > 0) {
+          for (int i = 0; i < req.getContextKeysCount(); i++) {
+            Collection<Ad> ads = service.getAdsByCategory(req.getContextKeys(i));
+            allAds.addAll(ads);
+          }
+        } else {
+          allAds = service.getRandomAds();
+        }
+        if (allAds.isEmpty()) {
+          // Serve random ads.
+          allAds = service.getRandomAds();
+        }
+        AdResponse reply = AdResponse.newBuilder().addAllAds(allAds).build();
+        responseObserver.onNext(reply);
+        responseObserver.onCompleted();
+      } catch (StatusRuntimeException e) {
+        logger.log(Level.WARN, "GetAds Failed with status {}", e.getStatus());
+        responseObserver.onError(e);
+      }
+    }
+  }
+
+  private static final ImmutableListMultimap<String, Ad> adsMap = createAdsMap();
+
+  private Collection<Ad> getAdsByCategory(String category) {
+    return adsMap.get(category);
+  }
+
+  private static final Random random = new Random();
+
+  private List<Ad> getRandomAds() {
+    List<Ad> ads = new ArrayList<>(MAX_ADS_TO_SERVE);
+    Collection<Ad> allAds = adsMap.values();
+    for (int i = 0; i < MAX_ADS_TO_SERVE; i++) {
+      ads.add(Iterables.get(allAds, random.nextInt(allAds.size())));
+    }
+    return ads;
+  }
+
+  private static AdService getInstance() {
+    return service;
+  }
+
+  /** Await termination on the main thread since the grpc library uses daemon threads. */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  private static ImmutableListMultimap<String, Ad> createAdsMap() {
+    Ad hairdryer =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/2ZYFJ3GM2N")
+            .setText("Hairdryer for sale. 50% off.")
+            .build();
+    Ad tankTop =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/66VCHSJNUP")
+            .setText("Tank top for sale. 20% off.")
+            .build();
+    Ad candleHolder =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/0PUK6V6EV0")
+            .setText("Candle holder for sale. 30% off.")
+            .build();
+    Ad bambooGlassJar =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/9SIQT8TOJO")
+            .setText("Bamboo glass jar for sale. 10% off.")
+            .build();
+    Ad watch =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/1YMWWN1N4O")
+            .setText("Watch for sale. Buy one, get second kit for free")
+            .build();
+    Ad mug =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/6E92ZMYYFZ")
+            .setText("Mug for sale. Buy two, get third one for free")
+            .build();
+    Ad loafers =
+        Ad.newBuilder()
+            .setRedirectUrl("/product/L9ECAV7KIM")
+            .setText("Loafers for sale. Buy one, get second one for free")
+            .build();
+    return ImmutableListMultimap.<String, Ad>builder()
+        .putAll("clothing", tankTop)
+        .putAll("accessories", watch)
+        .putAll("footwear", loafers)
+        .putAll("hair", hairdryer)
+        .putAll("decor", candleHolder)
+        .putAll("kitchen", bambooGlassJar, mug)
+        .build();
+  }
+
+  private static void initStats() {
+    if (System.getenv("DISABLE_STATS") != null) {
+      logger.info("Stats disabled.");
+      return;
+    }
+    logger.info("Stats enabled, but temporarily unavailable");
+
+    long sleepTime = 10; /* seconds */
+    int maxAttempts = 5;
+
+    // TODO(arbrown) Implement OpenTelemetry stats
+
+  }
+
+  private static void initTracing() {
+    if (System.getenv("DISABLE_TRACING") != null) {
+      logger.info("Tracing disabled.");
+      return;
+    }
+    logger.info("Tracing enabled but temporarily unavailable");
+    logger.info("See https://github.com/GoogleCloudPlatform/microservices-demo/issues/422 for more info.");
+
+    // TODO(arbrown) Implement OpenTelemetry tracing
+    
+    logger.info("Tracing enabled - Stackdriver exporter initialized.");
+  }
+
+  /** Main launches the server from the command line. */
+  public static void main(String[] args) throws IOException, InterruptedException {
+
+    new Thread(
+            () -> {
+              initStats();
+              initTracing();
+            })
+        .start();
+
+    // Start the RPC server. You shouldn't see any output from gRPC before this.
+    logger.info("AdService starting.");
+    final AdService service = AdService.getInstance();
+    service.start();
+    service.blockUntilShutdown();
+  }
+}

benchmark/boutique/scheduling/111/code/adservice/src/main/java/hipstershop/AdServiceClient.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2018, Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package hipstershop;
+
+import hipstershop.Demo.Ad;
+import hipstershop.Demo.AdRequest;
+import hipstershop.Demo.AdResponse;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/** A simple client that requests ads from the Ads Service. */
+public class AdServiceClient {
+
+  private static final Logger logger = LogManager.getLogger(AdServiceClient.class);
+
+  private final ManagedChannel channel;
+  private final hipstershop.AdServiceGrpc.AdServiceBlockingStub blockingStub;
+
+  /** Construct client connecting to Ad Service at {@code host:port}. */
+  private AdServiceClient(String host, int port) {
+    this(
+        ManagedChannelBuilder.forAddress(host, port)
+            // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
+            // needing certificates.
+            .usePlaintext()
+            .build());
+  }
+
+  /** Construct client for accessing RouteGuide server using the existing channel. */
+  private AdServiceClient(ManagedChannel channel) {
+    this.channel = channel;
+    blockingStub = hipstershop.AdServiceGrpc.newBlockingStub(channel);
+  }
+
+  private void shutdown() throws InterruptedException {
+    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+  }
+
+  /** Get Ads from Server. */
+  public void getAds(String contextKey) {
+    logger.info("Get Ads with context " + contextKey + " ...");
+    AdRequest request = AdRequest.newBuilder().addContextKeys(contextKey).build();
+    AdResponse response;
+
+    try {
+      response = blockingStub.getAds(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARN, "RPC failed: " + e.getStatus());
+      return;
+    } 
+    for (Ad ads : response.getAdsList()) {
+      logger.info("Ads: " + ads.getText());
+    }
+  }
+
+  private static int getPortOrDefaultFromArgs(String[] args) {
+    int portNumber = 9555;
+    if (2 < args.length) {
+      try {
+        portNumber = Integer.parseInt(args[2]);
+      } catch (NumberFormatException e) {
+        logger.warn(String.format("Port %s is invalid, use default port %d.", args[2], 9555));
+      }
+    }
+    return portNumber;
+  }
+
+  private static String getStringOrDefaultFromArgs(
+      String[] args, int index, @Nullable String defaultString) {
+    String s = defaultString;
+    if (index < args.length) {
+      s = args[index];
+    }
+    return s;
+  }
+
+  /**
+   * Ads Service Client main. If provided, the first element of {@code args} is the context key to
+   * get the ads from the Ads Service
+   */
+  public static void main(String[] args) throws InterruptedException {
+    // Add final keyword to pass checkStyle.
+    final String contextKeys = getStringOrDefaultFromArgs(args, 0, "camera");
+    final String host = getStringOrDefaultFromArgs(args, 1, "localhost");
+    final int serverPort = getPortOrDefaultFromArgs(args);
+
+    AdServiceClient client = new AdServiceClient(host, serverPort);
+    try {
+      client.getAds(contextKeys);
+    } finally {
+      client.shutdown();
+    }
+
+    logger.info("Exiting AdServiceClient...");
+  }
+}