diff --git a/src/datasources/redis/datasource.ts b/src/datasources/redis/datasource.ts
index 6076585..aea11fc 100644
--- a/src/datasources/redis/datasource.ts
+++ b/src/datasources/redis/datasource.ts
@@ -96,6 +96,7 @@ export class PCPRedisDatasource {
     }
 
     async handleTarget(instancesValuesGroupedBySeries: Record<string, MetricValue[]>,
+        metricNames: Record<string, string>,
         descriptions: any, labels: any, target: QueryTarget): Promise<TargetResult> {
         const metrics: Metric<number | string>[] = [];
 
@@ -125,7 +126,7 @@ export class PCPRedisDatasource {
             }
 
             metrics.push({
-                name: target.expr, // TODO: metric, not expression
+                name: metricNames[series],
                 instances: metricInstances
             });
         }
@@ -179,10 +180,11 @@ export class PCPRedisDatasource {
 
         const instances = await this.pmSeriesSrv.getValues(seriesList, { start, finish, samples });
         const descriptions = await this.pmSeriesSrv.getDescriptions(seriesList);
+        const metricNames = await this.pmSeriesSrv.getMetricNames(seriesList);
         const instanceValuesGroupedBySeries = _.groupBy(instances, "series");
         const labels = this.pmSeriesSrv.getMetricAndInstanceLabels(seriesList);
         const targetResults = await Promise.all(targets.map(target => this.handleTarget(
-            _.pick(instanceValuesGroupedBySeries, seriesByExpr[target.expr]), descriptions, labels, target
+            _.pick(instanceValuesGroupedBySeries, seriesByExpr[target.expr]), metricNames, descriptions, labels, target
         )));
         const panelData = this.transformations.transform(query, targetResults, PCPRedisDatasource.defaultLegendFormatter);
         return {
diff --git a/src/datasources/redis/pmseries_srv.ts b/src/datasources/redis/pmseries_srv.ts
index e3c59c6..f3686a5 100644
--- a/src/datasources/redis/pmseries_srv.ts
+++ b/src/datasources/redis/pmseries_srv.ts
@@ -8,6 +8,11 @@ export interface LabelsResponse {
     labels: Labels;
 }
 
+export interface MetricNamesResponse {
+    series: string;
+    name: string;
+}
+
 class PmSeriesApi {
 
     constructor(private datasourceRequest: DatasourceRequestFn, private url: string) {
@@ -67,6 +72,15 @@ class PmSeriesApi {
         return _.isArray(metrics) ? metrics : []; // TODO: on error (no metrics found), pmproxy returns an object (should be an empty array)
     }
 
+    async metricsSeries(series: string[]): Promise<MetricNamesResponse[]> {
+        const response = await this.datasourceRequest({
+            url: `${this.url}/series/metrics`,
+            params: { series: series.join(',') }
+        });
+        const metricNames = response.data;
+        return _.isArray(metricNames) ? metricNames : []; // TODO: on error (no metrics found), pmproxy returns an object (should be an empty array)
+    }
+
     async labels(series: string[]): Promise<LabelsResponse[]> {
         const response = await this.datasourceRequest({
             url: `${this.url}/series/labels`,
@@ -84,6 +98,7 @@ export class PmSeriesSrv {
     private instanceCache: Record<string, Record<string, Instance>> = {}; // instanceCache[series][instance] = instance;
     private labelCache: Record<string, Labels> = {}; // labelCache[series_or_instance] = labels;
     private metricNamesCache: Record<string, string[]> = {}; // metricNamesCache[prefix] = name[];
+    private metricNameOfSeriesCache: Record<string, string> = {};
 
     constructor(datasourceRequest: DatasourceRequestFn, url: string) {
         this.pmSeriesApi = new PmSeriesApi(datasourceRequest, url);
@@ -108,6 +123,17 @@ export class PmSeriesSrv {
         return _.pick(this.descriptionCache, series);
     }
 
+    async getMetricNames(series: string[]): Promise<Record<string, string>> {
+        const requiredSeries = _.difference(series, Object.keys(this.metricNameOfSeriesCache));
+        if (requiredSeries.length > 0) {
+            const metricNames = await this.pmSeriesApi.metricsSeries(requiredSeries);
+            for (const metricName of metricNames) {
+                this.metricNameOfSeriesCache[metricName.series] = metricName.name;
+            }
+        }
+        return _.pick(this.metricNameOfSeriesCache, series);
+    }
+
     async getInstances(series: string[], ignoreCache = false): Promise<Record<string, Record<string, Instance>>> {
         const requiredSeries = ignoreCache ? series : _.difference(series, Object.keys(this.instanceCache));
         if (requiredSeries.length > 0) {