Implementing canActivate doesn't work if I return a value inside the subscribe

You should not use subscribeinside a guard because what it needs is a Observableas such and what calling this function returns is a Subscriptionwhich is the one that contains the method unsubscribeand so that the guard internally can register the emission of values ​​what it needs is be able to access the same one subscribethat is included in the interface of the Observable.

You can use the operator mapto transform the value you receive when executing your function isLogged()and return one of the values ​​that guards can process . Ideally these values ​​should be trueif access is allowed or an UrlTreeif it is not. For example:

import { Injectable } from '@angular/core';
import { CanActivate, Router, UrlTree } from '@angular/router';
import { LoginService } from '../login.service';
import { Observable, of } from 'rxjs';
import { map, catchError } from 'rxjs/operators';
import { StorageService } from '../storage.service';

@Injectable({
  providedIn: 'root'
})
export class AuthGuard implements CanActivate {

  constructor( private _login: LoginService,
               private _router: Router,
               private _session: StorageService) {}

  canActivate(): Observable<boolean> | boolean | Observable<UrlTree> | UrlTree {

    return this._login.isLogged()
        .pipe(
            // Si la petición es exitosa se puede proceder
            map(() => true),
            // Si la peticion tiene un error de estado >= 400 se dirige al login
            catchError(() => {
               this._session.deleteData();
               return of(this._router.createUrlTree(['/login']))
            })
        );
    }
}

They UrlTreeare supported as of Angular >= 7.1 , can be easily created with the function createUrlTree , and are used as a better alternative to typing navigateaccompanied by return false. For example these codes inside a guard are equivalent :

this._router.navigate(['/login']);
return false;

a

return this._router.createUrlTree(['/login']);

If you use a version lower than 7.1 you will have to use the first alternative but in no case should you just return false without navigating because the user will not know that an error has occurred.

Here I leave a more detailed explanation of the operators

map(() => true)

equals

map(result => {
    return true;
})

Whatever the result, if the http status code is in the range of the 200guard will receive a value trueand proceed to navigate to the requested route

catchError(() => {
    this._session.deleteData();
    return of(this._router.createUrlTree(['/login']))
})

If the result status code is you >=400call the method deleteDataand return an observable using ofthat will produce a static value and then complete. This static value is UrlTreewhat the guard expects to know where it should go.

You can use the map operator to return, for example

export class DataComponent{
  someMethod() {
    return this.http.get(path).map(res => {
      return res.json();
    });
  }
} 

Adding the returnand using pipegot you going in the right direction, but you missed handling errors, it looks like you removed that part of the code:

canActivate(): Observable<boolean> | boolean {

  return this._login.isLogged().pipe(
    map((data: any) => {
      if( data.auth ) {
        return true;
      } else {
        this._session.deleteData();
        this._router.navigate(['/login']);
        return false;
      }
    }),
    catchError(() => {
      this._session.deleteData();
      this._router.navigate(['/login']);
      return false;
    })
  );
}

You can try to do the following

You subscribe to the service and capture the result in a variable

  this.servicio.metodoServicio().subscribe(
        result => {
              // puedes validar que resultado tiene result , este variable guarda lo que llegue del servidor 

In your case it would be like this

this._login.isLogged().subscribe(
      // Si la respuesta es un código HTTP 204, entonces está autorizado
      result => {
           // debes validar la estructura de datos que llega en el result
           if(result.code) {
            // aqui returnas el true
           } else {
               this._session.deleteData();
               this._router.navigate(['/login']);
               return false;
           }
      });

The issue is that the subscribe does not return what is as its parameter, but the subscribe returns a Subscription object.

You could only return this._login.isLogged()and subscribe in the part of the code that calls canActivate().