com.wavefront.agent.preprocessor.InteractivePreprocessorTester Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of proxy Show documentation
Service for batching and relaying metric traffic to Wavefront
There is a newer version: 4.36
package com.wavefront.agent.preprocessor;

import com.wavefront.agent.InteractiveTester;
import com.wavefront.agent.formatter.DataFormat;
import com.wavefront.agent.handlers.HandlerKey;
import com.wavefront.agent.handlers.ReportableEntityHandler;
import com.wavefront.agent.handlers.ReportableEntityHandlerFactory;
import com.wavefront.agent.listeners.WavefrontPortUnificationHandler;
import com.wavefront.agent.listeners.tracing.SpanUtils;
import com.wavefront.data.ReportableEntityType;
import com.wavefront.ingester.HistogramDecoder;
import com.wavefront.ingester.ReportPointDecoder;
import com.wavefront.ingester.ReportPointDecoderWrapper;
import com.wavefront.ingester.ReportPointSerializer;
import com.wavefront.ingester.ReportableEntityDecoder;
import com.wavefront.ingester.SpanDecoder;
import com.wavefront.ingester.SpanSerializer;
import java.util.List;
import java.util.Scanner;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import wavefront.report.ReportPoint;
import wavefront.report.Span;

/**
 * Interactive tester for preprocessor rules.
 *
 * @author [email protected]
 */
public class InteractivePreprocessorTester implements InteractiveTester {
  private static final SpanSerializer SPAN_SERIALIZER = new SpanSerializer();
  private static final ReportableEntityDecoder SPAN_DECODER =
      new SpanDecoder("unknown");

  private final Scanner stdin = new Scanner(System.in);
  private final Supplier preprocessorSupplier;
  private final ReportableEntityType entityType;
  private final String port;
  private final List customSourceTags;

  private final ReportableEntityHandlerFactory factory =
      new ReportableEntityHandlerFactory() {
        @SuppressWarnings("unchecked")
        @Override
        public  ReportableEntityHandler getHandler(HandlerKey handlerKey) {
          if (handlerKey.getEntityType() == ReportableEntityType.TRACE) {
            return (ReportableEntityHandler)
                new ReportableEntityHandler() {
                  @Override
                  public void report(Span reportSpan) {
                    System.out.println(SPAN_SERIALIZER.apply(reportSpan));
                  }

                  @Override
                  public void block(Span reportSpan) {
                    System.out.println("Blocked: " + reportSpan);
                  }

                  @Override
                  public void block(@Nullable Span reportSpan, @Nullable String message) {
                    System.out.println("Blocked: " + SPAN_SERIALIZER.apply(reportSpan));
                  }

                  @Override
                  public void reject(@Nullable Span reportSpan, @Nullable String message) {
                    System.out.println("Rejected: " + SPAN_SERIALIZER.apply(reportSpan));
                  }

                  @Override
                  public void reject(@Nonnull String t, @Nullable String message) {
                    System.out.println("Rejected: " + t);
                  }

                  @Override
                  public void setLogFormat(DataFormat format) {
                    throw new UnsupportedOperationException();
                  }

                  @Override
                  public void shutdown() {}
                };
          }
          return (ReportableEntityHandler)
              new ReportableEntityHandler() {
                @Override
                public void report(ReportPoint reportPoint) {
                  System.out.println(ReportPointSerializer.pointToString(reportPoint));
                }

                @Override
                public void block(ReportPoint reportPoint) {
                  System.out.println(
                      "Blocked: " + ReportPointSerializer.pointToString(reportPoint));
                }

                @Override
                public void block(@Nullable ReportPoint reportPoint, @Nullable String message) {
                  System.out.println(
                      "Blocked: " + ReportPointSerializer.pointToString(reportPoint));
                }

                @Override
                public void reject(@Nullable ReportPoint reportPoint, @Nullable String message) {
                  System.out.println(
                      "Rejected: " + ReportPointSerializer.pointToString(reportPoint));
                }

                @Override
                public void reject(@Nonnull String t, @Nullable String message) {
                  System.out.println("Rejected: " + t);
                }

                @Override
                public void setLogFormat(DataFormat format) {
                  throw new UnsupportedOperationException();
                }

                @Override
                public void shutdown() {}
              };
        }

        @Override
        public void shutdown(@Nonnull String handle) {}
      };

  /**
   * @param preprocessorSupplier supplier for {@link ReportableEntityPreprocessor}
   * @param entityType entity type (to determine whether it's a span or a point)
   * @param port handler key
   * @param customSourceTags list of custom source tags (for parsing)
   */
  public InteractivePreprocessorTester(
      Supplier preprocessorSupplier,
      ReportableEntityType entityType,
      String port,
      List customSourceTags) {
    this.preprocessorSupplier = preprocessorSupplier;
    this.entityType = entityType;
    this.port = port;
    this.customSourceTags = customSourceTags;
  }

  @Override
  public boolean interactiveTest() {
    String line = stdin.nextLine();
    if (entityType == ReportableEntityType.TRACE) {
      ReportableEntityHandler handler = factory.getHandler(entityType, port);
      SpanUtils.preprocessAndHandleSpan(
          line, SPAN_DECODER, handler, handler::report, preprocessorSupplier, null, x -> true);
    } else {
      ReportableEntityHandler handler = factory.getHandler(entityType, port);
      ReportableEntityDecoder decoder;
      if (DataFormat.autodetect(line) == DataFormat.HISTOGRAM) {
        decoder = new ReportPointDecoderWrapper(new HistogramDecoder());
      } else {
        decoder = new ReportPointDecoder(() -> "unknown", customSourceTags);
      }
      WavefrontPortUnificationHandler.preprocessAndHandlePoint(
          line, decoder, handler, preprocessorSupplier, null, "");
    }
    return stdin.hasNext();
  }
}