clearcut_client/com/android/tradefed/clearcut/ClearcutClient.java - platform/tools/tradefederation - Git at Google

 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
  * 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 com.android.tradefed.clearcut;

 import com.android.annotations.VisibleForTesting;
 import com.android.asuite.clearcut.Clientanalytics.ClientInfo;
 import com.android.asuite.clearcut.Clientanalytics.LogEvent;
 import com.android.asuite.clearcut.Clientanalytics.LogRequest;
 import com.android.asuite.clearcut.Clientanalytics.LogResponse;
 import com.android.asuite.clearcut.Common.UserType;
 import com.android.tradefed.invoker.tracing.CloseableTraceScope;
 import com.android.tradefed.log.LogUtil.CLog;
 import com.android.tradefed.util.CommandResult;
 import com.android.tradefed.util.CommandStatus;
 import com.android.tradefed.util.FileUtil;
 import com.android.tradefed.util.RunUtil;
 import com.android.tradefed.util.StreamUtil;
 import com.android.tradefed.util.net.HttpHelper;

 import com.google.common.base.Strings;
 import com.google.protobuf.util.JsonFormat;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.net.HttpURLConnection;
 import java.net.InetAddress;
 import java.net.URL;
 import java.net.UnknownHostException;
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;

 /** Client that allows reporting usage metrics to clearcut. */
 public class ClearcutClient {

     public static final String DISABLE_CLEARCUT_KEY = "DISABLE_CLEARCUT";
     private static final String CLEARCUT_SUB_TOOL_NAME = "CLEARCUT_SUB_TOOL_NAME";

     private static final String CLEARCUT_PROD_URL = "https://play.googleapis.com/log";
     private static final int CLIENT_TYPE = 1;
     private static final int INTERNAL_LOG_SOURCE = 971;
     private static final int EXTERNAL_LOG_SOURCE = 934;

     private static final long SCHEDULER_INITIAL_DELAY_MILLISECONDS = 1000;
     private static final long SCHEDULER_PERDIOC_MILLISECONDS = 250;

     private static final String GOOGLE_EMAIL = "@google.com";
     private static final String GOOGLE_HOSTNAME = ".google.com";

     private File mCachedUuidFile = new File(System.getProperty("user.home"), ".tradefed");
     private String mRunId;
     private long mSessionStartTime = 0L;

     private final int mLogSource;
     private final String mUrl;
     private final UserType mUserType;
     private final String mSubToolName;

     // Consider synchronized list
     private List<LogRequest> mExternalEventQueue;
     // The pool executor to actually post the metrics
     private ScheduledThreadPoolExecutor mExecutor;
     // Whether the clearcut client should be inop
     private boolean mDisabled = false;

     public ClearcutClient(String subToolName) {
         this(null, subToolName);
     }

     /**
      * Create Client with customized posting URL and forcing whether it's internal or external user.
      */
     @VisibleForTesting
     protected ClearcutClient(String url, String subToolName) {
         mDisabled = isClearcutDisabled();

         // We still have to set the 'final' variable so go through the assignments before returning
         if (!mDisabled && isGoogleUser()) {
             mLogSource = INTERNAL_LOG_SOURCE;
             mUserType = UserType.GOOGLE;
         } else {
             mLogSource = EXTERNAL_LOG_SOURCE;
             mUserType = UserType.EXTERNAL;
         }
         if (url == null) {
             mUrl = CLEARCUT_PROD_URL;
         } else {
             mUrl = url;
         }
         mRunId = UUID.randomUUID().toString();
         mExternalEventQueue = new ArrayList<>();
         if (Strings.isNullOrEmpty(subToolName) && System.getenv(CLEARCUT_SUB_TOOL_NAME) != null) {
             mSubToolName = System.getenv(CLEARCUT_SUB_TOOL_NAME);
         } else {
             mSubToolName = subToolName;
         }

         if (mDisabled) {
             return;
         }

         // Print the notice
         System.out.println(NoticeMessageUtil.getNoticeMessage(mUserType));

         // Executor to actually send the events.
         mExecutor =
                 new ScheduledThreadPoolExecutor(
                         1,
                         new ThreadFactory() {
                             @Override
                             public Thread newThread(Runnable r) {
                                 Thread t = Executors.defaultThreadFactory().newThread(r);
                                 t.setDaemon(true);
                                 t.setName("clearcut-client-thread");
                                 return t;
                             }
                         });
         Runnable command =
                 new Runnable() {
                     @Override
                     public void run() {
                         flushEvents();
                     }
                 };
         mExecutor.scheduleAtFixedRate(
                 command,
                 SCHEDULER_INITIAL_DELAY_MILLISECONDS,
                 SCHEDULER_PERDIOC_MILLISECONDS,
                 TimeUnit.MILLISECONDS);
     }

     /** Send the first event to notify that Tradefed was started. */
     public void notifyTradefedStartEvent() {
         if (mDisabled) {
             return;
         }
         mSessionStartTime = System.nanoTime();
         long eventTimeMs = System.currentTimeMillis();
         CompletableFuture.supplyAsync(() -> createStartEvent(eventTimeMs));
     }

     private boolean createStartEvent(long eventTimeMs) {
         LogRequest.Builder request = createBaseLogRequest();
         LogEvent.Builder logEvent = LogEvent.newBuilder();
         logEvent.setEventTimeMs(eventTimeMs);
         logEvent.setSourceExtension(
                 ClearcutEventHelper.createStartEvent(
                         getGroupingKey(), mRunId, mUserType, mSubToolName));
         request.addLogEvent(logEvent);
         queueEvent(request.build());
         return true;
     }

     /** Send the last event to notify that Tradefed is done. */
     public void notifyTradefedFinishedEvent() {
         if (mDisabled) {
             return;
         }
         Duration duration = java.time.Duration.ofNanos(System.nanoTime() - mSessionStartTime);
         LogRequest.Builder request = createBaseLogRequest();
         LogEvent.Builder logEvent = LogEvent.newBuilder();
         logEvent.setEventTimeMs(System.currentTimeMillis());
         logEvent.setSourceExtension(
                 ClearcutEventHelper.createFinishedEvent(
                         getGroupingKey(), mRunId, mUserType, mSubToolName, duration));
         request.addLogEvent(logEvent);
         queueEvent(request.build());
     }

     /** Send the event to notify that a Tradefed invocation was started. */
     public void notifyTradefedInvocationStartEvent() {
         if (mDisabled) {
             return;
         }
         LogRequest.Builder request = createBaseLogRequest();
         LogEvent.Builder logEvent = LogEvent.newBuilder();
         logEvent.setEventTimeMs(System.currentTimeMillis());
         logEvent.setSourceExtension(
                 ClearcutEventHelper.createRunStartEvent(
                         getGroupingKey(), mRunId, mUserType, mSubToolName));
         request.addLogEvent(logEvent);
         queueEvent(request.build());
     }

     /** Send the event to notify that a test run finished. */
     public void notifyTestRunFinished(long startTimeNano) {
         if (mDisabled) {
             return;
         }
         Duration duration = java.time.Duration.ofNanos(System.nanoTime() - startTimeNano);
         LogRequest.Builder request = createBaseLogRequest();
         LogEvent.Builder logEvent = LogEvent.newBuilder();
         logEvent.setEventTimeMs(System.currentTimeMillis());
         logEvent.setSourceExtension(
                 ClearcutEventHelper.creatRunTestFinished(
                         getGroupingKey(), mRunId, mUserType, mSubToolName, duration));
         request.addLogEvent(logEvent);
         queueEvent(request.build());
     }

     /** Stop the periodic sending of clearcut events */
     public void stop() {
         if (mExecutor != null) {
             mExecutor.setRemoveOnCancelPolicy(true);
             mExecutor.shutdown();
             mExecutor = null;
         }
         // Send all remaining events
         flushEvents();
     }

     /** Add an event to the queue of events that needs to be send. */
     public void queueEvent(LogRequest event) {
         synchronized (mExternalEventQueue) {
             mExternalEventQueue.add(event);
         }
     }

     /** Returns the current queue size. */
     public final int getQueueSize() {
         synchronized (mExternalEventQueue) {
             return mExternalEventQueue.size();
         }
     }

     /** Allows to override the default cached uuid file. */
     public void setCachedUuidFile(File uuidFile) {
         mCachedUuidFile = uuidFile;
     }

     /** Get a new or the cached uuid for the user. */
     @VisibleForTesting
     String getGroupingKey() {
         String uuid = null;
         if (mCachedUuidFile.exists()) {
             try {
                 uuid = FileUtil.readStringFromFile(mCachedUuidFile);
             } catch (IOException e) {
                 CLog.e(e);
             }
         }
         if (uuid == null || uuid.isEmpty()) {
             uuid = UUID.randomUUID().toString();
             try {
                 FileUtil.writeToFile(uuid, mCachedUuidFile);
             } catch (IOException e) {
                 CLog.e(e);
             }
         }
         return uuid;
     }

     /** Returns True if clearcut is disabled, False otherwise. */
     @VisibleForTesting
     public boolean isClearcutDisabled() {
         return "1".equals(System.getenv(DISABLE_CLEARCUT_KEY));
     }

     /** Returns True if the user is a Googler, False otherwise. */
     @VisibleForTesting
     boolean isGoogleUser() {
         try {
             String hostname = InetAddress.getLocalHost().getHostName();
             if (hostname.contains(GOOGLE_HOSTNAME)) {
                 return true;
             }
         } catch (UnknownHostException e) {
             // Ignore
         }
         CommandResult gitRes =
                 RunUtil.getDefault()
                         .runTimedCmdSilently(60000L, "git", "config", "--get", "user.email");
         if (CommandStatus.SUCCESS.equals(gitRes.getStatus())) {
             String stdout = gitRes.getStdout();
             if (stdout != null && stdout.trim().endsWith(GOOGLE_EMAIL)) {
                 return true;
             }
         }

         return false;
     }

     private LogRequest.Builder createBaseLogRequest() {
         LogRequest.Builder request = LogRequest.newBuilder();
         request.setLogSource(mLogSource);
         request.setClientInfo(ClientInfo.newBuilder().setClientType(CLIENT_TYPE));
         return request;
     }

     private void flushEvents() {
         List<LogRequest> copy = new ArrayList<>();
         synchronized (mExternalEventQueue) {
             copy.addAll(mExternalEventQueue);
             mExternalEventQueue.clear();
         }
         List<CompletableFuture<Boolean>> futures = new ArrayList<>();
         while (!copy.isEmpty()) {
             LogRequest event = copy.remove(0);
             futures.add(CompletableFuture.supplyAsync(() -> sendToClearcut(event)));
         }

         for (CompletableFuture<Boolean> future : futures) {
             try {
                 future.get();
             } catch (InterruptedException | ExecutionException e) {
                 CLog.e(e);
             }
         }
     }

     /** Send one event to the configured server. */
     private boolean sendToClearcut(LogRequest event) {
         HttpHelper helper = new HttpHelper();

         InputStream inputStream = null;
         InputStream errorStream = null;
         OutputStream outputStream = null;
         OutputStreamWriter outputStreamWriter = null;
         try (CloseableTraceScope ignored = new CloseableTraceScope("sendToClearcut")) {
             HttpURLConnection connection = helper.createConnection(new URL(mUrl), "POST", "text");
             outputStream = connection.getOutputStream();
             outputStreamWriter = new OutputStreamWriter(outputStream);

             String jsonObject = JsonFormat.printer().preservingProtoFieldNames().print(event);
             outputStreamWriter.write(jsonObject.toString());
             outputStreamWriter.flush();

             inputStream = connection.getInputStream();
             LogResponse response = LogResponse.parseFrom(inputStream);

             errorStream = connection.getErrorStream();
             if (errorStream != null) {
                 String message = StreamUtil.getStringFromStream(errorStream);
                 CLog.e("Error posting clearcut event: '%s'. LogResponse: '%s'", message, response);
             }
         } catch (IOException e) {
             CLog.e(e);
         } finally {
             StreamUtil.close(outputStream);
             StreamUtil.close(inputStream);
             StreamUtil.close(outputStreamWriter);
             StreamUtil.close(errorStream);
         }
         return true;
     }
 }
	/*
	* Copyright (C) 2019 The Android Open Source Project
	*
	* 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 com.android.tradefed.clearcut;

	import com.android.annotations.VisibleForTesting;
	import com.android.asuite.clearcut.Clientanalytics.ClientInfo;
	import com.android.asuite.clearcut.Clientanalytics.LogEvent;
	import com.android.asuite.clearcut.Clientanalytics.LogRequest;
	import com.android.asuite.clearcut.Clientanalytics.LogResponse;
	import com.android.asuite.clearcut.Common.UserType;
	import com.android.tradefed.invoker.tracing.CloseableTraceScope;
	import com.android.tradefed.log.LogUtil.CLog;
	import com.android.tradefed.util.CommandResult;
	import com.android.tradefed.util.CommandStatus;
	import com.android.tradefed.util.FileUtil;
	import com.android.tradefed.util.RunUtil;
	import com.android.tradefed.util.StreamUtil;
	import com.android.tradefed.util.net.HttpHelper;

	import com.google.common.base.Strings;
	import com.google.protobuf.util.JsonFormat;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.OutputStreamWriter;
	import java.net.HttpURLConnection;
	import java.net.InetAddress;
	import java.net.URL;
	import java.net.UnknownHostException;
	import java.time.Duration;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.UUID;
	import java.util.concurrent.CompletableFuture;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.Executors;
	import java.util.concurrent.ScheduledThreadPoolExecutor;
	import java.util.concurrent.ThreadFactory;
	import java.util.concurrent.TimeUnit;

	/** Client that allows reporting usage metrics to clearcut. */
	public class ClearcutClient {

	public static final String DISABLE_CLEARCUT_KEY = "DISABLE_CLEARCUT";
	private static final String CLEARCUT_SUB_TOOL_NAME = "CLEARCUT_SUB_TOOL_NAME";

	private static final String CLEARCUT_PROD_URL = "https://play.googleapis.com/log";
	private static final int CLIENT_TYPE = 1;
	private static final int INTERNAL_LOG_SOURCE = 971;
	private static final int EXTERNAL_LOG_SOURCE = 934;

	private static final long SCHEDULER_INITIAL_DELAY_MILLISECONDS = 1000;
	private static final long SCHEDULER_PERDIOC_MILLISECONDS = 250;

	private static final String GOOGLE_EMAIL = "@google.com";
	private static final String GOOGLE_HOSTNAME = ".google.com";

	private File mCachedUuidFile = new File(System.getProperty("user.home"), ".tradefed");
	private String mRunId;
	private long mSessionStartTime = 0L;

	private final int mLogSource;
	private final String mUrl;
	private final UserType mUserType;
	private final String mSubToolName;

	// Consider synchronized list
	private List<LogRequest> mExternalEventQueue;
	// The pool executor to actually post the metrics
	private ScheduledThreadPoolExecutor mExecutor;
	// Whether the clearcut client should be inop
	private boolean mDisabled = false;

	public ClearcutClient(String subToolName) {
	this(null, subToolName);
	}

	/**
	* Create Client with customized posting URL and forcing whether it's internal or external user.
	*/
	@VisibleForTesting
	protected ClearcutClient(String url, String subToolName) {
	mDisabled = isClearcutDisabled();

	// We still have to set the 'final' variable so go through the assignments before returning
	if (!mDisabled && isGoogleUser()) {
	mLogSource = INTERNAL_LOG_SOURCE;
	mUserType = UserType.GOOGLE;
	} else {
	mLogSource = EXTERNAL_LOG_SOURCE;
	mUserType = UserType.EXTERNAL;
	}
	if (url == null) {
	mUrl = CLEARCUT_PROD_URL;
	} else {
	mUrl = url;
	}
	mRunId = UUID.randomUUID().toString();
	mExternalEventQueue = new ArrayList<>();
	if (Strings.isNullOrEmpty(subToolName) && System.getenv(CLEARCUT_SUB_TOOL_NAME) != null) {
	mSubToolName = System.getenv(CLEARCUT_SUB_TOOL_NAME);
	} else {
	mSubToolName = subToolName;
	}

	if (mDisabled) {
	return;
	}

	// Print the notice
	System.out.println(NoticeMessageUtil.getNoticeMessage(mUserType));

	// Executor to actually send the events.
	mExecutor =
	new ScheduledThreadPoolExecutor(
	1,
	new ThreadFactory() {
	@Override
	public Thread newThread(Runnable r) {
	Thread t = Executors.defaultThreadFactory().newThread(r);
	t.setDaemon(true);
	t.setName("clearcut-client-thread");
	return t;
	}
	});
	Runnable command =
	new Runnable() {
	@Override
	public void run() {
	flushEvents();
	}
	};
	mExecutor.scheduleAtFixedRate(
	command,
	SCHEDULER_INITIAL_DELAY_MILLISECONDS,
	SCHEDULER_PERDIOC_MILLISECONDS,
	TimeUnit.MILLISECONDS);
	}

	/** Send the first event to notify that Tradefed was started. */
	public void notifyTradefedStartEvent() {
	if (mDisabled) {
	return;
	}
	mSessionStartTime = System.nanoTime();
	long eventTimeMs = System.currentTimeMillis();
	CompletableFuture.supplyAsync(() -> createStartEvent(eventTimeMs));
	}

	private boolean createStartEvent(long eventTimeMs) {
	LogRequest.Builder request = createBaseLogRequest();
	LogEvent.Builder logEvent = LogEvent.newBuilder();
	logEvent.setEventTimeMs(eventTimeMs);
	logEvent.setSourceExtension(
	ClearcutEventHelper.createStartEvent(
	getGroupingKey(), mRunId, mUserType, mSubToolName));
	request.addLogEvent(logEvent);
	queueEvent(request.build());
	return true;
	}

	/** Send the last event to notify that Tradefed is done. */
	public void notifyTradefedFinishedEvent() {
	if (mDisabled) {
	return;
	}
	Duration duration = java.time.Duration.ofNanos(System.nanoTime() - mSessionStartTime);
	LogRequest.Builder request = createBaseLogRequest();
	LogEvent.Builder logEvent = LogEvent.newBuilder();
	logEvent.setEventTimeMs(System.currentTimeMillis());
	logEvent.setSourceExtension(
	ClearcutEventHelper.createFinishedEvent(
	getGroupingKey(), mRunId, mUserType, mSubToolName, duration));
	request.addLogEvent(logEvent);
	queueEvent(request.build());
	}

	/** Send the event to notify that a Tradefed invocation was started. */
	public void notifyTradefedInvocationStartEvent() {
	if (mDisabled) {
	return;
	}
	LogRequest.Builder request = createBaseLogRequest();
	LogEvent.Builder logEvent = LogEvent.newBuilder();
	logEvent.setEventTimeMs(System.currentTimeMillis());
	logEvent.setSourceExtension(
	ClearcutEventHelper.createRunStartEvent(
	getGroupingKey(), mRunId, mUserType, mSubToolName));
	request.addLogEvent(logEvent);
	queueEvent(request.build());
	}

	/** Send the event to notify that a test run finished. */
	public void notifyTestRunFinished(long startTimeNano) {
	if (mDisabled) {
	return;
	}
	Duration duration = java.time.Duration.ofNanos(System.nanoTime() - startTimeNano);
	LogRequest.Builder request = createBaseLogRequest();
	LogEvent.Builder logEvent = LogEvent.newBuilder();
	logEvent.setEventTimeMs(System.currentTimeMillis());
	logEvent.setSourceExtension(
	ClearcutEventHelper.creatRunTestFinished(
	getGroupingKey(), mRunId, mUserType, mSubToolName, duration));
	request.addLogEvent(logEvent);
	queueEvent(request.build());
	}

	/** Stop the periodic sending of clearcut events */
	public void stop() {
	if (mExecutor != null) {
	mExecutor.setRemoveOnCancelPolicy(true);
	mExecutor.shutdown();
	mExecutor = null;
	}
	// Send all remaining events
	flushEvents();
	}

	/** Add an event to the queue of events that needs to be send. */
	public void queueEvent(LogRequest event) {
	synchronized (mExternalEventQueue) {
	mExternalEventQueue.add(event);
	}
	}

	/** Returns the current queue size. */
	public final int getQueueSize() {
	synchronized (mExternalEventQueue) {
	return mExternalEventQueue.size();
	}
	}

	/** Allows to override the default cached uuid file. */
	public void setCachedUuidFile(File uuidFile) {
	mCachedUuidFile = uuidFile;
	}

	/** Get a new or the cached uuid for the user. */
	@VisibleForTesting
	String getGroupingKey() {
	String uuid = null;
	if (mCachedUuidFile.exists()) {
	try {
	uuid = FileUtil.readStringFromFile(mCachedUuidFile);
	} catch (IOException e) {
	CLog.e(e);
	}
	}
	if (uuid == null \|\| uuid.isEmpty()) {
	uuid = UUID.randomUUID().toString();
	try {
	FileUtil.writeToFile(uuid, mCachedUuidFile);
	} catch (IOException e) {
	CLog.e(e);
	}
	}
	return uuid;
	}

	/** Returns True if clearcut is disabled, False otherwise. */
	@VisibleForTesting
	public boolean isClearcutDisabled() {
	return "1".equals(System.getenv(DISABLE_CLEARCUT_KEY));
	}

	/** Returns True if the user is a Googler, False otherwise. */
	@VisibleForTesting
	boolean isGoogleUser() {
	try {
	String hostname = InetAddress.getLocalHost().getHostName();
	if (hostname.contains(GOOGLE_HOSTNAME)) {
	return true;
	}
	} catch (UnknownHostException e) {
	// Ignore
	}
	CommandResult gitRes =
	RunUtil.getDefault()
	.runTimedCmdSilently(60000L, "git", "config", "--get", "user.email");
	if (CommandStatus.SUCCESS.equals(gitRes.getStatus())) {
	String stdout = gitRes.getStdout();
	if (stdout != null && stdout.trim().endsWith(GOOGLE_EMAIL)) {
	return true;
	}
	}

	return false;
	}

	private LogRequest.Builder createBaseLogRequest() {
	LogRequest.Builder request = LogRequest.newBuilder();
	request.setLogSource(mLogSource);
	request.setClientInfo(ClientInfo.newBuilder().setClientType(CLIENT_TYPE));
	return request;
	}

	private void flushEvents() {
	List<LogRequest> copy = new ArrayList<>();
	synchronized (mExternalEventQueue) {
	copy.addAll(mExternalEventQueue);
	mExternalEventQueue.clear();
	}
	List<CompletableFuture<Boolean>> futures = new ArrayList<>();
	while (!copy.isEmpty()) {
	LogRequest event = copy.remove(0);
	futures.add(CompletableFuture.supplyAsync(() -> sendToClearcut(event)));
	}

	for (CompletableFuture<Boolean> future : futures) {
	try {
	future.get();
	} catch (InterruptedException \| ExecutionException e) {
	CLog.e(e);
	}
	}
	}

	/** Send one event to the configured server. */
	private boolean sendToClearcut(LogRequest event) {
	HttpHelper helper = new HttpHelper();

	InputStream inputStream = null;
	InputStream errorStream = null;
	OutputStream outputStream = null;
	OutputStreamWriter outputStreamWriter = null;
	try (CloseableTraceScope ignored = new CloseableTraceScope("sendToClearcut")) {
	HttpURLConnection connection = helper.createConnection(new URL(mUrl), "POST", "text");
	outputStream = connection.getOutputStream();
	outputStreamWriter = new OutputStreamWriter(outputStream);

	String jsonObject = JsonFormat.printer().preservingProtoFieldNames().print(event);
	outputStreamWriter.write(jsonObject.toString());
	outputStreamWriter.flush();

	inputStream = connection.getInputStream();
	LogResponse response = LogResponse.parseFrom(inputStream);

	errorStream = connection.getErrorStream();
	if (errorStream != null) {
	String message = StreamUtil.getStringFromStream(errorStream);
	CLog.e("Error posting clearcut event: '%s'. LogResponse: '%s'", message, response);
	}
	} catch (IOException e) {
	CLog.e(e);
	} finally {
	StreamUtil.close(outputStream);
	StreamUtil.close(inputStream);
	StreamUtil.close(outputStreamWriter);
	StreamUtil.close(errorStream);
	}
	return true;
	}
	}