Spymemcached

<!-- https://mvnrepository.com/artifact/io.orijtech.integrations/ocspymemcached -->
<dependency>
  <groupId>io.orijtech.integrations</groupId>
  <artifactId>ocspymemcached</artifactId>
  <version>0.0.1</version>
</dependency>

// https://mvnrepository.com/artifact/io.orijtech.integrations/ocspymemcached
compile group: 'io.orijtech.integrations', name: 'ocspymemcached', version: '0.0.1'

<!-- https://mvnrepository.com/artifact/io.orijtech.integrations/ocspymemcached -->
<dependency org="io.orijtech.integrations" name="ocspymemcached" rev="0.0.1"/>

# https://mvnrepository.com/artifact/io.orijtech.integrations/ocspymemcached
'io.orijtech.integrations:ocspymemcached:jar:0.0.1'

// Please place this code sample in your current working directory in this file:
//   src/main/java/io/opencensus/tutorials/ocspymemcached/MemcachedOpenCensusTutorial.java
package io.opencensus.tutorials.ocspymemcached;

import io.opencensus.common.Scope;
import io.opencensus.exporter.stats.prometheus.PrometheusStatsCollector;
import io.opencensus.exporter.trace.zipkin.ZipkinTraceExporter;
import io.opencensus.trace.Tracer;
import io.opencensus.trace.Tracing;
import io.opencensus.trace.config.TraceConfig;
import io.opencensus.trace.samplers.Samplers;
import io.orijtech.integrations.ocspymemcached.Observability;
import io.orijtech.integrations.ocspymemcached.OcWrapClient;
import io.prometheus.client.exporter.HTTPServer;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import net.spy.memcached.internal.GetFuture;
import net.spy.memcached.internal.OperationFuture;

public class MemcachedOpenCensusTutorial {
  public static void main(String[] args) {
    OcWrapClient mc;

    try {
      // Create the wrapped Memcached client.
      mc = new OcWrapClient(new InetSocketAddress("localhost", 11211));
    } catch (Exception e) {
      System.err.println("Failed to create Memcached client: " + e.toString());
      return;
    }

    // Enable exporting of all the Memcached specific metrics and views.
    Observability.registerAllViews();

    // Now enable OpenCensus exporters.
    setupOpenCensusExporters();

    // Create the tracer that we'll use to create custom spans.
    Tracer tracer = Tracing.getTracer();

    // Then prepare the source for queries i.e. standard input.
    BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));

    while (true) {
      String query = "";

      try {
        // Print out the prompt.
        System.out.print("> ");
        System.out.flush();

        // Read the input.
        query = stdin.readLine();
      } catch (Exception e) {
        System.err.println("Exception " + e);
        return;
      }

      if (query.length() == 0) query = "*";

      // Create our custom span that will be the parent of all the child
      // spans from the instrumentation inside the Memcached client wrapper.
      // This span is optional but is useful to group and examine the flow
      // of requests.
      Scope ss = tracer.spanBuilder("MemcachedOpenCensusTutorial").startScopedSpan();

      System.out.println(query);

      try {
        // Perform an asynchronous Get to get back a Future.
        GetFuture<Object> getRes = mc.asyncGet(query);

        // You can perform some work here on the main thread,
        // since the asyncGet is run asynchronously/in-the-background.

        String result = "";

        // Now attempt to get the result from the Future.
        try {
          result = (String) getRes.get();
        } catch (Exception e) {
          System.err.println("Result.Get exception: " + e);
        }

        Boolean cacheHit = result != null && result != "";

        if (cacheHit) {
          System.out.println("Cache hit!");
        } else {
          // Cache miss, so process the data and then
          // memoize it for later cache hits.
          System.out.println("Cache miss");

          // Performing some "expensive" processing here.
          // This could be something more sophisticated
          // like searching for media, emails, reservations etc.
          result = query.toUpperCase();

          // Process it in the background so that
          // we that we don't block on our critical path.
          mc.set(query, 3600, result);
        }

        System.out.println("< " + result + "\n");

        if (cacheHit && System.nanoTime() % 2 == 1) {
          OperationFuture<Boolean> deleteFuture = mc.delete(query);

          // In this case we have to wait for the deletion to complete.
          // We can otherwise take out the waiting code.
          try {
            Boolean success = deleteFuture.get();
            if (success) System.out.println("Successfully performed delete!");
            else System.err.println("Failed to perform delete!");

          } catch (Exception e) {
            System.err.println("Deletion failed with exception: " + e);
          }
        }
      } finally {
        // End our custom span.
        ss.close();
      }
    }
  }

  private static void setupOpenCensusExporters() {
    // Firstly, change the sampling rate to always sample so
    // that our demo can always produce trace spans.
    // This rate is very high, please lower it in production apps!
    TraceConfig traceConfig = Tracing.getTraceConfig();
    traceConfig.updateActiveTraceParams(
        traceConfig.getActiveTraceParams().toBuilder().setSampler(Samplers.alwaysSample()).build());

    try {
      // Create the Zipkin Trace exporter.
      ZipkinTraceExporter.createAndRegister(
          "http://localhost:9411/api/v2/spans", "spymemcached-opencensus");

      // Create the Prometheus stats scrape endpoint.
      PrometheusStatsCollector.createAndRegister();
      // Run the server as a daemon on address "localhost:8888"
      HTTPServer server = new HTTPServer("localhost", 8888, true);
    } catch (Exception e) {
      System.err.println("Failed to setup OpenCensus Exporters " + e);
    }
  }
}

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>io.opencensus.tutorials</groupId>
    <artifactId>ocspymemcached</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>ocspymemcached</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <opencensus.version>0.18.0</opencensus.version>
        <ocspymemcached.version>0.0.2</ocspymemcached.version>
        <prometheus.server.version>0.3.0</prometheus.server.version>
        <maven.plugin.version>1.5.0.Final</maven.plugin.version>
        <java.source.version>1.8</java.source.version>
        <maven.compiler.version>3.7.0</maven.compiler.version>
        <codehaus.version>1.10</codehaus.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>io.orijtech.integrations</groupId>
            <artifactId>ocspymemcached</artifactId>
            <version>${ocspymemcached.version}</version>
        </dependency>

        <dependency>
            <groupId>io.opencensus</groupId>
            <artifactId>opencensus-api</artifactId>
            <version>${opencensus.version}</version>
        </dependency>

        <dependency>
            <groupId>io.opencensus</groupId>
            <artifactId>opencensus-impl</artifactId>
            <version>${opencensus.version}</version>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>io.opencensus</groupId>
            <artifactId>opencensus-exporter-trace-zipkin</artifactId>
            <version>${opencensus.version}</version>
        </dependency>

        <dependency>
            <groupId>io.opencensus</groupId>
            <artifactId>opencensus-exporter-stats-prometheus</artifactId>
            <version>${opencensus.version}</version>
        </dependency>

        <dependency>
            <groupId>io.prometheus</groupId>
            <artifactId>simpleclient_httpserver</artifactId>
            <version>${prometheus.server.version}</version>
        </dependency>
    </dependencies>

    <build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>${maven.plugin.version}</version>
            </extension>
        </extensions>

        <pluginManagement>
          <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.version}</version>
                <configuration>
                    <source>${java.source.version}</source>
                    <target>${java.source.version}</target>
                </configuration>
            </plugin>
          </plugins>
        </pluginManagement>

        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>appassembler-maven-plugin</artifactId>
                <version>${codehaus.version}</version>
                <configuration>
                    <programs>
                        <program>
                            <id>MemcachedOpenCensus</id>
                            <mainClass>io.opencensus.tutorials.ocspymemcached.MemcachedOpenCensusTutorial</mainClass>
                        </program>
                    </programs>
                </configuration>
            </plugin>

        </plugins>
    </build>

</project>